@usine/core 0.0.0 → 0.1.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,cAAc,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,OAAO,MAAM,wBAAwB,CAAC;AAClD,OAAO,KAAK,cAAc,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,KAAK,MAAM,sBAAsB,CAAC;AAC9C,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAC;AAC5C,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAC;AAC5C,OAAO,KAAK,GAAG,MAAM,oBAAoB,CAAC;AAC1C,OAAO,KAAK,QAAQ,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,IAAI,MAAM,qBAAqB,CAAC"}

package/dist/instance.d.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+/**
+ * Value object (branded path): absolute or caller-resolved path to the
+ * instance folder (ADR 0001). Shared by every package that anchors itself to
+ * the instance repo — the engine's database adapters and the config loader.
+ */
+export declare const Directory: Schema.brand<Schema.NonEmptyString, "InstanceDirectory">;
+export type Directory = typeof Directory.Type;
+//# sourceMappingURL=instance.d.ts.map

package/dist/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,SAAS,0DAAgE,CAAC;AACvF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC"}

package/dist/instance.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+/**
+ * Value object (branded path): absolute or caller-resolved path to the
+ * instance folder (ADR 0001). Shared by every package that anchors itself to
+ * the instance repo — the engine's database adapters and the config loader.
+ */
+export const Directory = Schema.NonEmptyString.pipe(Schema.brand("InstanceDirectory"));
+//# sourceMappingURL=instance.js.map

package/dist/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC"}

package/dist/lifecycle/attempt-failure.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Why an attempt failed — the typed taxonomy the retry law dispatches on
+ * (ADR 0002, ADR 0013). Typed errors; three classes, deliberately distinct:
+ *
+ * - `InfraFailure` — the only class the engine may retry on its own, capped.
+ * - `AgentFailure` — always waits for the operator.
+ * - `RunawayFailure` — never auto-retried; only the operator restarts it.
+ */
+import { Schema } from "effect";
+declare const InfraFailure_base: Schema.Class<InfraFailure, Schema.TaggedStruct<"InfraFailure", {
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Typed error: infrastructure failed around the agent — worker unreachable,
+ * checkout failed, run host died. Auto-retryable, capped.
+ */
+export declare class InfraFailure extends InfraFailure_base {
+}
+declare const AgentFailure_base: Schema.Class<AgentFailure, Schema.TaggedStruct<"AgentFailure", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Typed error: the agent ran and failed the work itself. Never auto-retried —
+ * an agent that failed once would fail the same way again; the operator
+ * decides what changes before the next attempt.
+ */
+export declare class AgentFailure extends AgentFailure_base {
+}
+/** Which per-attempt ceiling the runaway guard tripped. */
+export declare const RunawayCeiling: Schema.Literals<readonly ["wall-clock", "tokens"]>;
+export type RunawayCeiling = typeof RunawayCeiling.Type;
+declare const RunawayFailure_base: Schema.Class<RunawayFailure, Schema.TaggedStruct<"RunawayFailure", {
+    readonly ceiling: Schema.Literals<readonly ["wall-clock", "tokens"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Typed error: the runaway guard interrupted an attempt burning without
+ * progress. Its own class so auto-retry can never touch it (ADR 0013).
+ */
+export declare class RunawayFailure extends RunawayFailure_base {
+}
+export declare const AttemptFailure: Schema.Union<readonly [typeof InfraFailure, typeof AgentFailure, typeof RunawayFailure]>;
+export type AttemptFailure = typeof AttemptFailure.Type;
+/**
+ * The class half of the auto-retry law (ADR 0002): only infra failures are
+ * ever auto-retried. This deliberately ignores the attempt cap — the full
+ * capped decision is `Attempt.shouldAutoRetry`.
+ */
+export declare const isAutoRetryable: <I>(input: I) => input is I & InfraFailure;
+export {};
+//# sourceMappingURL=attempt-failure.d.ts.map

package/dist/lifecycle/attempt-failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt-failure.d.ts","sourceRoot":"","sources":["../../src/lifecycle/attempt-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;;;;;AAEhC;;;GAGG;AACH,qBAAa,YAAa,SAAQ,iBAMjC;CAAG;;;;AAEJ;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,iBAKjC;CAAG;AAEJ,2DAA2D;AAC3D,eAAO,MAAM,cAAc,oDAA4C,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC;;;;AAExD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,mBAIlC;CAAG;AAEL,eAAO,MAAM,cAAc,0FAA6D,CAAC;AACzF,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,eAAe,4CAA0B,CAAC"}

package/dist/lifecycle/attempt-failure.js

@@ -0,0 +1,45 @@
+/**
+ * Why an attempt failed — the typed taxonomy the retry law dispatches on
+ * (ADR 0002, ADR 0013). Typed errors; three classes, deliberately distinct:
+ *
+ * - `InfraFailure` — the only class the engine may retry on its own, capped.
+ * - `AgentFailure` — always waits for the operator.
+ * - `RunawayFailure` — never auto-retried; only the operator restarts it.
+ */
+import { Schema } from "effect";
+/**
+ * Typed error: infrastructure failed around the agent — worker unreachable,
+ * checkout failed, run host died. Auto-retryable, capped.
+ */
+export class InfraFailure extends Schema.TaggedError("AttemptFailure/InfraFailure")("InfraFailure", {
+    message: Schema.String,
+    cause: Schema.Defect(),
+}) {
+}
+/**
+ * Typed error: the agent ran and failed the work itself. Never auto-retried —
+ * an agent that failed once would fail the same way again; the operator
+ * decides what changes before the next attempt.
+ */
+export class AgentFailure extends Schema.TaggedError("AttemptFailure/AgentFailure")("AgentFailure", {
+    message: Schema.String,
+}) {
+}
+/** Which per-attempt ceiling the runaway guard tripped. */
+export const RunawayCeiling = Schema.Literals(["wall-clock", "tokens"]);
+/**
+ * Typed error: the runaway guard interrupted an attempt burning without
+ * progress. Its own class so auto-retry can never touch it (ADR 0013).
+ */
+export class RunawayFailure extends Schema.TaggedError("AttemptFailure/RunawayFailure")("RunawayFailure", {
+    ceiling: RunawayCeiling,
+}) {
+}
+export const AttemptFailure = Schema.Union([InfraFailure, AgentFailure, RunawayFailure]);
+/**
+ * The class half of the auto-retry law (ADR 0002): only infra failures are
+ * ever auto-retried. This deliberately ignores the attempt cap — the full
+ * capped decision is `Attempt.shouldAutoRetry`.
+ */
+export const isAutoRetryable = Schema.is(InfraFailure);
+//# sourceMappingURL=attempt-failure.js.map

package/dist/lifecycle/attempt-failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt-failure.js","sourceRoot":"","sources":["../../src/lifecycle/attempt-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;GAGG;AACH,MAAM,OAAO,YAAa,SAAQ,MAAM,CAAC,WAAW,CAAe,6BAA6B,CAAC,CAC/F,cAAc,EACd;IACE,OAAO,EAAE,MAAM,CAAC,MAAM;IACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE;CACvB,CACF;CAAG;AAEJ;;;;GAIG;AACH,MAAM,OAAO,YAAa,SAAQ,MAAM,CAAC,WAAW,CAAe,6BAA6B,CAAC,CAC/F,cAAc,EACd;IACE,OAAO,EAAE,MAAM,CAAC,MAAM;CACvB,CACF;CAAG;AAEJ,2DAA2D;AAC3D,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC;AAGxE;;;GAGG;AACH,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC,WAAW,CACpD,+BAA+B,CAChC,CAAC,gBAAgB,EAAE;IAClB,OAAO,EAAE,cAAc;CACxB,CAAC;CAAG;AAEL,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC;AAGzF;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC"}

package/dist/lifecycle/attempt.d.ts

@@ -0,0 +1,61 @@
+import { Schema } from "effect";
+import { AttemptFailure } from "./attempt-failure.ts";
+import { BrainSpec } from "../agent.ts";
+/**
+ * Value object (branded id): identity of one Attempt.
+ */
+export declare const AttemptId: Schema.brand<Schema.NonEmptyString, "AttemptId">;
+export type AttemptId = typeof AttemptId.Type;
+/**
+ * Value object: 1-based position of a try under its step — retries are
+ * attempt N+1 under the same step, never new runs. Also the unit of the
+ * auto-retry cap: a cap of 3 means at most three attempts in total.
+ */
+export declare const AttemptNumber: Schema.brand<Schema.Int, "AttemptNumber">;
+export type AttemptNumber = typeof AttemptNumber.Type;
+declare const Succeeded_base: Schema.Class<Succeeded, Schema.TaggedStruct<"Succeeded", {}>, {}>;
+/** Outcome — value object: the attempt finished; the step result is stored on the Step. */
+export declare class Succeeded extends Succeeded_base {
+}
+declare const Failed_base: Schema.Class<Failed, Schema.TaggedStruct<"Failed", {
+    readonly failure: Schema.Union<readonly [typeof import("./attempt-failure.ts").InfraFailure, typeof import("./attempt-failure.ts").AgentFailure, typeof import("./attempt-failure.ts").RunawayFailure]>;
+}>, {}>;
+/** Outcome — value object: the attempt failed, with the typed failure that closed it. */
+export declare class Failed extends Failed_base {
+}
+declare const Canceled_base: Schema.Class<Canceled, Schema.TaggedStruct<"Canceled", {}>, {}>;
+/** Outcome — value object: the operator canceled the Run during this Attempt. */
+export declare class Canceled extends Canceled_base {
+}
+export declare const Outcome: Schema.Union<readonly [typeof Succeeded, typeof Failed, typeof Canceled]>;
+export type Outcome = typeof Outcome.Type;
+declare const Attempt_base: Schema.Class<Attempt, Schema.Struct<{
+    readonly id: Schema.brand<Schema.NonEmptyString, "AttemptId">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "RunId">;
+    readonly stepName: Schema.brand<Schema.NonEmptyString, "StepName">;
+    readonly worker: Schema.brand<Schema.String, "WorkerName">;
+    readonly number: Schema.brand<Schema.Int, "AttemptNumber">;
+    readonly brain: typeof BrainSpec;
+    readonly parentModel: Schema.OptionFromNullOr<Schema.brand<Schema.String, "ModelId">>;
+    readonly startedAt: Schema.DateTimeUtc;
+    readonly outcome: Schema.Option<Schema.Union<readonly [typeof Succeeded, typeof Failed, typeof Canceled]>>;
+}>, {}>;
+/**
+ * Entity — ledger row: one try of a step on a worker. `outcome` is none while
+ * the attempt is in flight.
+ */
+export declare class Attempt extends Attempt_base {
+}
+/**
+ * Deriver — the full auto-retry law over one failed attempt (ADR 0002,
+ * ADR 0013): the class rule (`AttemptFailure.isAutoRetryable` — infra only)
+ * capped by the attempt count. `maxAutoAttempts` counts total attempts:
+ * attempt N may auto-retry into attempt N+1 only while N < maxAutoAttempts.
+ */
+export declare const shouldAutoRetry: (options: {
+    readonly failure: AttemptFailure;
+    readonly number: AttemptNumber;
+    readonly maxAutoAttempts: AttemptNumber;
+}) => boolean;
+export {};
+//# sourceMappingURL=attempt.d.ts.map

package/dist/lifecycle/attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt.d.ts","sourceRoot":"","sources":["../../src/lifecycle/attempt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAmB,MAAM,sBAAsB,CAAC;AAGvE,OAAO,EAAE,SAAS,EAAW,MAAM,aAAa,CAAC;AAGjD;;GAEG;AACH,eAAO,MAAM,SAAS,kDAAwD,CAAC;AAC/E,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,aAAa,2CAEzB,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAC;;AAEtD,2FAA2F;AAC3F,qBAAa,SAAU,SAAQ,cAG9B;CAAG;;;;AAEJ,yFAAyF;AACzF,qBAAa,MAAO,SAAQ,WAE1B;CAAG;;AAEL,iFAAiF;AACjF,qBAAa,QAAS,SAAQ,aAG7B;CAAG;AAEJ,eAAO,MAAM,OAAO,2EAA8C,CAAC;AACnE,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;AAE1C;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,YAU3B;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,eAAe,YAAa;IACvC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC;CACzC,KAAG,OAAuF,CAAC"}

package/dist/lifecycle/attempt.js

@@ -0,0 +1,52 @@
+import { Schema } from "effect";
+import { AttemptFailure, isAutoRetryable } from "./attempt-failure.js";
+import { RunId } from "./run.js";
+import { StepName } from "./step.js";
+import { BrainSpec, ModelId } from "../agent.js";
+import { Name as WorkerName } from "../worker.js";
+/**
+ * Value object (branded id): identity of one Attempt.
+ */
+export const AttemptId = Schema.NonEmptyString.pipe(Schema.brand("AttemptId"));
+/**
+ * Value object: 1-based position of a try under its step — retries are
+ * attempt N+1 under the same step, never new runs. Also the unit of the
+ * auto-retry cap: a cap of 3 means at most three attempts in total.
+ */
+export const AttemptNumber = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).pipe(Schema.brand("AttemptNumber"));
+/** Outcome — value object: the attempt finished; the step result is stored on the Step. */
+export class Succeeded extends Schema.TaggedClass("AttemptOutcome/Succeeded")("Succeeded", {}) {
+}
+/** Outcome — value object: the attempt failed, with the typed failure that closed it. */
+export class Failed extends Schema.TaggedClass("AttemptOutcome/Failed")("Failed", {
+    failure: AttemptFailure,
+}) {
+}
+/** Outcome — value object: the operator canceled the Run during this Attempt. */
+export class Canceled extends Schema.TaggedClass("AttemptOutcome/Canceled")("Canceled", {}) {
+}
+export const Outcome = Schema.Union([Succeeded, Failed, Canceled]);
+/**
+ * Entity — ledger row: one try of a step on a worker. `outcome` is none while
+ * the attempt is in flight.
+ */
+export class Attempt extends Schema.Class("Attempt")({
+    id: AttemptId,
+    runId: RunId,
+    stepName: StepName,
+    worker: WorkerName,
+    number: AttemptNumber,
+    brain: BrainSpec,
+    parentModel: Schema.OptionFromNullOr(ModelId),
+    startedAt: Schema.DateTimeUtc,
+    outcome: Schema.Option(Outcome),
+}) {
+}
+/**
+ * Deriver — the full auto-retry law over one failed attempt (ADR 0002,
+ * ADR 0013): the class rule (`AttemptFailure.isAutoRetryable` — infra only)
+ * capped by the attempt count. `maxAutoAttempts` counts total attempts:
+ * attempt N may auto-retry into attempt N+1 only while N < maxAutoAttempts.
+ */
+export const shouldAutoRetry = (options) => isAutoRetryable(options.failure) && options.number < options.maxAutoAttempts;
+//# sourceMappingURL=attempt.js.map

package/dist/lifecycle/attempt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt.js","sourceRoot":"","sources":["../../src/lifecycle/attempt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AAElD;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;AAG/E;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAClF,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAC9B,CAAC;AAGF,2FAA2F;AAC3F,MAAM,OAAO,SAAU,SAAQ,MAAM,CAAC,WAAW,CAAY,0BAA0B,CAAC,CACtF,WAAW,EACX,EAAE,CACH;CAAG;AAEJ,yFAAyF;AACzF,MAAM,OAAO,MAAO,SAAQ,MAAM,CAAC,WAAW,CAAS,uBAAuB,CAAC,CAAC,QAAQ,EAAE;IACxF,OAAO,EAAE,cAAc;CACxB,CAAC;CAAG;AAEL,iFAAiF;AACjF,MAAM,OAAO,QAAS,SAAQ,MAAM,CAAC,WAAW,CAAW,yBAAyB,CAAC,CACnF,UAAU,EACV,EAAE,CACH;CAAG;AAEJ,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;AAGnE;;;GAGG;AACH,MAAM,OAAO,OAAQ,SAAQ,MAAM,CAAC,KAAK,CAAU,SAAS,CAAC,CAAC;IAC5D,EAAE,EAAE,SAAS;IACb,KAAK,EAAE,KAAK;IACZ,QAAQ,EAAE,QAAQ;IAClB,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,aAAa;IACrB,KAAK,EAAE,SAAS;IAChB,WAAW,EAAE,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC,WAAW;IAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;CAChC,CAAC;CAAG;AAEL;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,OAI/B,EAAW,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC"}

package/dist/lifecycle/event.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+/**
+ * Value object (branded id): identity of one Event in the ledger.
+ */
+export declare const EventId: Schema.brand<Schema.NonEmptyString, "EventId">;
+export type EventId = typeof EventId.Type;
+/**
+ * Value object: the engine-derived, never-expiring idempotency key — timestamps aside, the
+ * same watched state is the same Event, forever. Derived per trigger type,
+ * never authored in a loop file (ADR 0002).
+ */
+export declare const DedupKey: Schema.brand<Schema.NonEmptyString, "DedupKey">;
+export type DedupKey = typeof DedupKey.Type;
+declare const Event_base: Schema.Class<Event, Schema.Struct<{
+    readonly id: Schema.brand<Schema.NonEmptyString, "EventId">;
+    readonly dedupKey: Schema.brand<Schema.NonEmptyString, "DedupKey">;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly receivedAt: Schema.DateTimeUtc;
+}>, {}>;
+/**
+ * Entity — ledger row: one deduplicated fact the engine may react to — a trigger matching watched
+ * state, or an operator approval. An Event owns at most one open Run, ever.
+ *
+ * The payload is the stream's payload slice — GitHub's own shapes, kept opaque
+ * here; the expression and loop-file blocks range over it.
+ */
+export declare class Event extends Event_base {
+}
+export {};
+//# sourceMappingURL=event.d.ts.map

package/dist/lifecycle/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/lifecycle/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;GAEG;AACH,eAAO,MAAM,OAAO,gDAAsD,CAAC;AAC3E,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,QAAQ,iDAAuD,CAAC;AAC7E,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAC;;;;;;;AAE5C;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,UAKzB;CAAG"}

package/dist/lifecycle/event.js

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+/**
+ * Value object (branded id): identity of one Event in the ledger.
+ */
+export const EventId = Schema.NonEmptyString.pipe(Schema.brand("EventId"));
+/**
+ * Value object: the engine-derived, never-expiring idempotency key — timestamps aside, the
+ * same watched state is the same Event, forever. Derived per trigger type,
+ * never authored in a loop file (ADR 0002).
+ */
+export const DedupKey = Schema.NonEmptyString.pipe(Schema.brand("DedupKey"));
+/**
+ * Entity — ledger row: one deduplicated fact the engine may react to — a trigger matching watched
+ * state, or an operator approval. An Event owns at most one open Run, ever.
+ *
+ * The payload is the stream's payload slice — GitHub's own shapes, kept opaque
+ * here; the expression and loop-file blocks range over it.
+ */
+export class Event extends Schema.Class("Event")({
+    id: EventId,
+    dedupKey: DedupKey,
+    payload: Schema.Json,
+    receivedAt: Schema.DateTimeUtc,
+}) {
+}
+//# sourceMappingURL=event.js.map

package/dist/lifecycle/event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/lifecycle/event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;AAG3E;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;AAG7E;;;;;;GAMG;AACH,MAAM,OAAO,KAAM,SAAQ,MAAM,CAAC,KAAK,CAAQ,OAAO,CAAC,CAAC;IACtD,EAAE,EAAE,OAAO;IACX,QAAQ,EAAE,QAAQ;IAClB,OAAO,EAAE,MAAM,CAAC,IAAI;IACpB,UAAU,EAAE,MAAM,CAAC,WAAW;CAC/B,CAAC;CAAG"}

package/dist/lifecycle/item.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+/**
+ * Value object: stable identity of one piece of software-work state inside a
+ * loop. Several content-distinct Events may concern the same Item.
+ */
+export declare const ItemKey: Schema.brand<Schema.NonEmptyString, "ItemKey">;
+export type ItemKey = typeof ItemKey.Type;
+/** Positive repository-local number for an issue-like Item. */
+export declare const Number: Schema.brand<Schema.Int, "ItemNumber">;
+export type Number = typeof Number.Type;
+//# sourceMappingURL=item.d.ts.map

package/dist/lifecycle/item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../src/lifecycle/item.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,OAAO,gDAAsD,CAAC;AAC3E,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAC;AAE1C,+DAA+D;AAC/D,eAAO,MAAM,MAAM,wCAElB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAC"}

package/dist/lifecycle/item.js

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+/**
+ * Value object: stable identity of one piece of software-work state inside a
+ * loop. Several content-distinct Events may concern the same Item.
+ */
+export const ItemKey = Schema.NonEmptyString.pipe(Schema.brand("ItemKey"));
+/** Positive repository-local number for an issue-like Item. */
+export const Number = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).pipe(Schema.brand("ItemNumber"));
+//# sourceMappingURL=item.js.map

package/dist/lifecycle/item.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item.js","sourceRoot":"","sources":["../../src/lifecycle/item.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;AAG3E,+DAA+D;AAC/D,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAC3E,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAC3B,CAAC"}

package/dist/lifecycle/loop.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+/**
+ * Value object (branded id): loop identity — the loop file's name in the instance repo. Filename is
+ * identity — renaming the file retires one loop and creates another
+ * (ADR 0001).
+ */
+export declare const LoopName: Schema.brand<Schema.NonEmptyString, "LoopName">;
+export type LoopName = typeof LoopName.Type;
+/**
+ * Value object: whether a loop parks new runs until an approval Event arrives
+ * (ADR 0004's `approval:` field, default none). One owner for the literal set
+ * the config parser accepts and the engine routes on.
+ */
+export declare const APPROVAL_REQUIREMENTS: readonly ["none", "required"];
+export declare const ApprovalRequirement: Schema.Literals<readonly ["none", "required"]>;
+export type ApprovalRequirement = typeof ApprovalRequirement.Type;
+//# sourceMappingURL=loop.d.ts.map

package/dist/lifecycle/loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/lifecycle/loop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,QAAQ,iDAAuD,CAAC;AAC7E,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,YAAI,MAAM,EAAE,UAAU,CAAU,CAAC;AACnE,eAAO,MAAM,mBAAmB,gDAAyC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAC"}

package/dist/lifecycle/loop.js

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+/**
+ * Value object (branded id): loop identity — the loop file's name in the instance repo. Filename is
+ * identity — renaming the file retires one loop and creates another
+ * (ADR 0001).
+ */
+export const LoopName = Schema.NonEmptyString.pipe(Schema.brand("LoopName"));
+/**
+ * Value object: whether a loop parks new runs until an approval Event arrives
+ * (ADR 0004's `approval:` field, default none). One owner for the literal set
+ * the config parser accepts and the engine routes on.
+ */
+export const APPROVAL_REQUIREMENTS = ["none", "required"];
+export const ApprovalRequirement = Schema.Literals(APPROVAL_REQUIREMENTS);
+//# sourceMappingURL=loop.js.map

package/dist/lifecycle/loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.js","sourceRoot":"","sources":["../../src/lifecycle/loop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;AAG7E;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,MAAM,EAAE,UAAU,CAAU,CAAC;AACnE,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/lifecycle/run-state.d.ts

@@ -0,0 +1,133 @@
+/**
+ * The run state machine (ADR 0002):
+ *
+ *   pending ──────────────► running ──► succeeded
+ *      │                    ▲  │
+ *      ▼                    │  ▼
+ *   waiting ────────────────┘ failed ──► (retry: attempt N+1) ──► running
+ *
+ *   pending | waiting | running ──► canceled   (operator cancel)
+ *   pending | waiting           ──► canceled   (supersede, revoke — a started
+ *                                               attempt always finishes, ADR 0007)
+ *
+ * States are value objects (a discriminated union, each state carrying exactly
+ * its own data). Transitions are typestate derivers: each function accepts
+ * only the states it is legal on, so an illegal transition is a compile
+ * error. Construct states through these transitions (or by parsing a stored
+ * row via the `RunState` union) — they are the state machine.
+ */
+import { Schema } from "effect";
+import { EventId } from "./event.ts";
+declare const OperatorCanceled_base: Schema.Class<OperatorCanceled, Schema.TaggedStruct<"OperatorCanceled", {}>, {}>;
+/** Cancel reason — value object: the operator closed the run by hand. */
+export declare class OperatorCanceled extends OperatorCanceled_base {
+}
+declare const Superseded_base: Schema.Class<Superseded, Schema.TaggedStruct<"Superseded", {
+    readonly by: Schema.brand<Schema.NonEmptyString, "EventId">;
+}>, {}>;
+/**
+ * Cancel reason — value object: a newer Event for the same Item took the
+ * run's place before any attempt started.
+ */
+export declare class Superseded extends Superseded_base {
+}
+declare const Revoked_base: Schema.Class<Revoked, Schema.TaggedStruct<"Revoked", {}>, {}>;
+/**
+ * Cancel reason — value object: the run's Item stopped matching its loop's
+ * trigger before any attempt started. Distinct from operator cancel and from
+ * supersede.
+ */
+export declare class Revoked extends Revoked_base {
+}
+export declare const CancelReason: Schema.Union<readonly [typeof OperatorCanceled, typeof Superseded, typeof Revoked]>;
+export type CancelReason = typeof CancelReason.Type;
+declare const Pending_base: Schema.Class<Pending, Schema.TaggedStruct<"Pending", {}>, {}>;
+/** Open: just created; no attempt started, no approval gate passed. */
+export declare class Pending extends Pending_base {
+}
+declare const Waiting_base: Schema.Class<Waiting, Schema.TaggedStruct<"Waiting", {}>, {}>;
+/**
+ * Open: parked on its loop's approval gate — v1's only waiting reason. The
+ * approval it consumes is an Event like every other fact.
+ */
+export declare class Waiting extends Waiting_base {
+}
+declare const Running_base: Schema.Class<Running, Schema.TaggedStruct<"Running", {}>, {}>;
+/** Open: an attempt is executing on a worker. */
+export declare class Running extends Running_base {
+}
+declare const Succeeded_base: Schema.Class<Succeeded, Schema.TaggedStruct<"Succeeded", {}>, {}>;
+/** Closed: the step finished and its result is stored. */
+export declare class Succeeded extends Succeeded_base {
+}
+declare const Failed_base: Schema.Class<Failed, Schema.TaggedStruct<"Failed", {}>, {}>;
+/**
+ * Closed, but reopenable: the last attempt failed and no auto-retry applies.
+ * The failure itself lives on the Attempt.
+ */
+export declare class Failed extends Failed_base {
+}
+declare const Canceled_base: Schema.Class<Canceled, Schema.TaggedStruct<"Canceled", {
+    readonly reason: Schema.Union<readonly [typeof OperatorCanceled, typeof Superseded, typeof Revoked]>;
+}>, {}>;
+/** Closed: canceled, with the reason recorded. */
+export declare class Canceled extends Canceled_base {
+}
+/**
+ * The open half of the machine — the single statement of the open/closed
+ * partition; the alias, the guard, and the full union all derive from it.
+ */
+export declare const Open: Schema.Union<readonly [typeof Pending, typeof Waiting, typeof Running]>;
+export type Open = typeof Open.Type;
+export declare const RunState: Schema.Union<readonly [typeof Pending, typeof Waiting, typeof Running, typeof Succeeded, typeof Failed, typeof Canceled]>;
+export type RunState = typeof RunState.Type;
+export declare const isOpen: <I>(input: I) => input is I & (Pending | Running | Waiting);
+/** The open partition as `_tag` literals, for queries that filter stored rows by state. */
+export declare const OPEN_STATE_TAGS: readonly ["Pending", "Waiting", "Running"];
+/** Every state as `_tag` literals, for read models that project stored rows by state. */
+export declare const STATE_TAGS: readonly ["Pending", "Waiting", "Running", "Succeeded", "Failed", "Canceled"];
+/**
+ * The states with no started attempt, as `_tag` literals — the precondition
+ * of `supersede` and `revoke`, for queries that filter stored rows by state.
+ */
+export declare const UNSTARTED_STATE_TAGS: readonly ["Pending", "Waiting"];
+/** pending → waiting: park the run on its loop's approval gate. */
+export declare const awaitApproval: (_state: Pending) => Waiting;
+/**
+ * pending | waiting → running: the first attempt starts. From waiting, the
+ * engine consumes the approval Event that opens the gate.
+ */
+export declare const start: (_state: Pending | Waiting) => Running;
+/** running → succeeded: the attempt finished and the step result is stored. */
+export declare const succeed: (_state: Running) => Succeeded;
+/**
+ * running → failed: the attempt failed and no auto-retry applies — the engine
+ * discharges that precondition with `Attempt.shouldAutoRetry`, the one owner
+ * of the auto-retry law.
+ */
+export declare const fail: (_state: Running) => Failed;
+/**
+ * failed → running: operator retry. The next try is a new Attempt (N+1) under
+ * the same Step, never a new run.
+ */
+export declare const retry: (_state: Failed) => Running;
+/**
+ * open → canceled: the operator's act, reachable from every open state —
+ * named by cause like its siblings; supersede and revoke are the other two
+ * roads into Canceled.
+ */
+export declare const cancelByOperator: (_state: Open) => Canceled;
+/**
+ * pending | waiting → canceled: a newer Event for the same Item takes this
+ * run's place. Only runs with no started attempt can be superseded — a running
+ * attempt always finishes, and the newer state is judged again when it ends
+ * (ADR 0007).
+ */
+export declare const supersede: (_state: Pending | Waiting, by: EventId) => Canceled;
+/**
+ * pending | waiting → canceled: the run's Item stopped matching its loop's
+ * trigger. Never touches a running attempt.
+ */
+export declare const revoke: (_state: Pending | Waiting) => Canceled;
+export {};
+//# sourceMappingURL=run-state.d.ts.map

package/dist/lifecycle/run-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-state.d.ts","sourceRoot":"","sources":["../../src/lifecycle/run-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;;AAErC,yEAAyE;AACzE,qBAAa,gBAAiB,SAAQ,qBAEb;CAAG;;;;AAE5B;;;GAGG;AACH,qBAAa,UAAW,SAAQ,eAG/B;CAAG;;AAEJ;;;;GAIG;AACH,qBAAa,OAAQ,SAAQ,YAAkE;CAAG;AAElG,eAAO,MAAM,YAAY,qFAAwD,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAC;;AAEpD,uEAAuE;AACvE,qBAAa,OAAQ,SAAQ,YAA8D;CAAG;;AAE9F;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,YAA8D;CAAG;;AAE9F,iDAAiD;AACjD,qBAAa,OAAQ,SAAQ,YAA8D;CAAG;;AAE9F,0DAA0D;AAC1D,qBAAa,SAAU,SAAQ,cAG9B;CAAG;;AAEJ;;;GAGG;AACH,qBAAa,MAAO,SAAQ,WAA2D;CAAG;;;;AAE1F,kDAAkD;AAClD,qBAAa,QAAS,SAAQ,aAE5B;CAAG;AAEL;;;GAGG;AACH,eAAO,MAAM,IAAI,yEAA4C,CAAC;AAC9D,MAAM,MAAM,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,CAAC;AAEpC,eAAO,MAAM,QAAQ,2HAA+D,CAAC;AACrF,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAC;AAE5C,eAAO,MAAM,MAAM,6DAAkB,CAAC;AAgBtC,2FAA2F;AAC3F,eAAO,MAAM,eAAe,4CAAkD,CAAC;AAE/E,yFAAyF;AACzF,eAAO,MAAM,UAAU,+EAOtB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,iCAAoD,CAAC;AAEtF,mEAAmE;AACnE,eAAO,MAAM,aAAa,WAAY,OAAO,KAAG,OAAwB,CAAC;AAEzE;;;GAGG;AACH,eAAO,MAAM,KAAK,WAAY,OAAO,GAAG,OAAO,KAAG,OAAwB,CAAC;AAE3E,+EAA+E;AAC/E,eAAO,MAAM,OAAO,WAAY,OAAO,KAAG,SAA4B,CAAC;AAEvE;;;;GAIG;AACH,eAAO,MAAM,IAAI,WAAY,OAAO,KAAG,MAAsB,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,KAAK,WAAY,MAAM,KAAG,OAAwB,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,WAAY,IAAI,KAAG,QACE,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,WAAY,OAAO,GAAG,OAAO,MAAM,OAAO,KAAG,QACjB,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,MAAM,WAAY,OAAO,GAAG,OAAO,KAAG,QACV,CAAC"}