@tenetkit/pg 0.40.1 → 0.41.2

package/dist/postgres/{store-ops.d.ts → store/ops.d.ts}

@@ -3,10 +3,10 @@ import type { PgClient } from "@effect/sql-pg";
 import { SqlClient } from "effect/unstable/sql";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 import { RunNotFound, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
-import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
-import type { DecodedRun } from "tenetkit/runtime/driver/sql/rows";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run/store";
+import type { DecodedRun } from "tenetkit/runtime/driver/sql/codec/rows";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/effect";
 type SqlR = SqlClient.SqlClient | PgClient.PgClient;
 export type RunFn = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | RuntimeUnavailable>;
 export declare const postgresOperations: (input: {
@@ -15,7 +15,7 @@ export declare const postgresOperations: (input: {
     readonly run: RunFn;
     readonly runNoTxn: RunFn;
     readonly requireRun: (runId: string) => Effect.Effect<DecodedRun, RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
-    readonly requireClaim: (claim: import("tenetkit/runtime/driver/run-store").ExecutionClaim) => Effect.Effect<void, import("tenetkit/runtime/driver/sql/errors").StaleClaim | RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
+    readonly requireClaim: (claim: import("tenetkit/runtime/driver/run/store").ExecutionClaim) => Effect.Effect<void, import("tenetkit/runtime/driver/sql/errors").StaleClaim | RunNotFound | RuntimeUnavailable | SqlError, SqlR>;
     readonly nextId: (prefix: string) => Effect.Effect<string>;
 }) => Pick<RunStoreInterface, "recordOperation" | "startOperation" | "completeOperation" | "commitModelResponse" | "commitInterruptedModelResponse" | "expireRunningOperation" | "recoverRunningOperations" | "getOperation" | "getOperationByKey" | "operationCancellations" | "acknowledgeOperationCancellation" | "resolveOperation">;
 export {};

package/dist/postgres/{store-ops.js → store/ops.js}

@@ -1,21 +1,26 @@
 import { Effect, Schema } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { OperationResolutionConflict, RunNotFound, RunTerminal, RuntimeUnavailable, } from "tenetkit/runtime/driver/errors";
-import { OperationResolution, digest as resolutionDigest } from "tenetkit/runtime/driver/operation-resolution";
+import { OperationResolution, digest as resolutionDigest } from "tenetkit/runtime/driver/operation/resolution";
 import { isTerminal } from "tenetkit/runtime/driver/run";
-import { ExecutionCheckpoint } from "tenetkit/runtime/driver/execution-state";
-import { decodeJson, encodeExecutableRef, encodeJson, encodeJsonValue } from "tenetkit/runtime/driver/sql/codecs";
+import { ExecutionCheckpoint } from "tenetkit/runtime/driver/execution/state";
+import { decodeJson, encodeExecutableRef, encodeJson, encodeJsonValue } from "tenetkit/runtime/driver/sql/codec/codecs";
 import { canBlindRetry } from "tenetkit/runtime/driver/sql/operations";
-import { appendEvent, toOperationRecord } from "./pg-helpers.js";
-import { encodeContinuation } from "tenetkit/runtime/driver/steering";
-import { checkpointRef } from "tenetkit/runtime/driver/executable-manifest";
-import { getProgramOperation, resolveProgramOperation } from "tenetkit/runtime/driver/sql/store-program";
-import { settleAdmittedCancellation } from "tenetkit/runtime/driver/sql/store-control";
-import { acknowledgeOperationCancellation, operationCancellations } from "tenetkit/runtime/driver/sql/store-operations";
-import { postgresModelResponseOperations } from "./store-model-response.js";
-import { appendHandoffSessionEntry, verifyHandoffSessionEntry } from "./session-store.js";
-import { handoffSessionEntry, isHandoffCommit, sameHandoffCheckpoint, sameHandoffCommit, } from "tenetkit/runtime/driver/handoff-session";
-import { lockRunHierarchy } from "./locks.js";
+import { appendEvent, toOperationRecord } from "./runtime.js";
+import { encodeContinuation } from "tenetkit/runtime/driver/run/steering";
+import { checkpointRef } from "tenetkit/runtime/driver/executable/manifest";
+import { getProgramOperation, resolveProgramOperation } from "tenetkit/runtime/driver/sql/store/program";
+import { settleAdmittedCancellation } from "tenetkit/runtime/driver/sql/store/control";
+import { acknowledgeOperationCancellation, operationCancellations, } from "tenetkit/runtime/driver/sql/store/operation/operations";
+import { postgresModelResponseOperations } from "./model-response.js";
+import { appendHandoffSessionEntry, verifyHandoffSessionEntry } from "../sessions/session-store.js";
+import { handoffSessionEntry, isHandoffCommit, sameHandoffCheckpoint, sameHandoffCommit, } from "tenetkit/runtime/driver/session/handoff";
+import { lockRunHierarchy } from "../runs/locks.js";
+const isCompletedOperationStatus = (status) => status === "cancelling" ||
+    status === "cancelled" ||
+    status === "succeeded" ||
+    status === "failed" ||
+    status === "unknown";
 export const postgresOperations = (input) => {
     const { sql, hub, run, runNoTxn, requireRun, requireClaim, nextId } = input;
     const fenced = (claim, effect) => run(sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireClaim(claim)), Effect.andThen(effect)));
@@ -51,6 +56,82 @@ export const postgresOperations = (input) => {
       `;
         return { record: toOperationRecord(next[0]), outcome: "unknown" };
     });
+    const existingOperation = (op, prior) => Effect.gen(function* () {
+        const consumed = yield* sql `
+        SELECT entry_id FROM tenetkit_run_steering
+        WHERE run_id = ${op.runId} AND consumed_operation_id = ${prior.operation_id}
+        ORDER BY sequence
+      `;
+        const retried = op.steeringEntryIds ?? [];
+        if (consumed.length !== retried.length || consumed.some((entry, index) => entry.entry_id !== retried[index])) {
+            return yield* RuntimeUnavailable.make({ message: "steering consumption does not match operation" });
+        }
+        return toOperationRecord(prior);
+    });
+    const verifyPendingSteering = (op) => Effect.gen(function* () {
+        const steeringEntryIds = op.steeringEntryIds ?? [];
+        const pending = yield* sql `
+        SELECT entry_id FROM tenetkit_run_steering
+        WHERE run_id = ${op.runId} AND consumed_operation_id IS NULL AND discarded_reason IS NULL
+        ORDER BY sequence
+      `;
+        const selected = pending.slice(0, steeringEntryIds.length);
+        if (selected.length !== steeringEntryIds.length ||
+            selected.some((entry, index) => entry.entry_id !== steeringEntryIds[index])) {
+            return yield* RuntimeUnavailable.make({ message: "steering entries are not the pending prefix" });
+        }
+        return steeringEntryIds;
+    });
+    const verifyCompletedOperation = (op, loaded, row) => Effect.gen(function* () {
+        const current = toOperationRecord(row);
+        if (current.kind === "handoff" && current.status === "succeeded" && isHandoffCommit(current.result)) {
+            if (op.outcome._tag !== "Succeeded" ||
+                !sameHandoffCommit(current.result, op.outcome.value) ||
+                !sameHandoffCheckpoint(loaded.driverCheckpoint, op.checkpoint)) {
+                return yield* RuntimeUnavailable.make({ message: "handoff operation has a divergent completion retry" });
+            }
+            const entry = handoffSessionEntry({
+                sessionId: loaded.message.sessionId,
+                operationKey: current.operationKey,
+                value: op.outcome.value,
+            });
+            if (Schema.is(RuntimeUnavailable)(entry))
+                return yield* entry;
+            yield* verifyHandoffSessionEntry(entry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
+        }
+        return current;
+    });
+    const verifyOperationSteering = (op) => Effect.gen(function* () {
+        for (const entryId of new Set(op.steeringEntryIds ?? [])) {
+            const rows = yield* sql `
+          SELECT consumed_operation_id FROM tenetkit_run_steering
+          WHERE run_id = ${op.runId} AND entry_id = ${entryId}
+        `;
+            if (rows[0]?.consumed_operation_id !== op.operationId) {
+                return yield* RuntimeUnavailable.make({ message: `steering entry ${entryId} does not belong to operation` });
+            }
+        }
+    });
+    const persistOperationOutcome = (op) => {
+        if (op.outcome._tag === "Succeeded") {
+            return sql `
+        UPDATE tenetkit_run_operations
+        SET status = 'succeeded', result_json = ${encodeJsonValue(op.outcome.value)}, finished_at = NOW()
+        WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status IN ('requested', 'running')
+      `;
+        }
+        if (op.outcome._tag === "Failed") {
+            return sql `
+        UPDATE tenetkit_run_operations
+        SET status = 'failed', error_json = ${encodeJsonValue(op.outcome.error)}, finished_at = NOW()
+        WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status IN ('requested', 'running')
+      `;
+        }
+        return sql `
+      UPDATE tenetkit_run_operations SET status = 'unknown', finished_at = NOW()
+      WHERE run_id = ${op.runId} AND operation_id = ${op.operationId} AND status IN ('requested', 'running')
+    `;
+    };
     return {
         recordOperation: (op) => fenced(op, Effect.gen(function* () {
             const loaded = yield* requireRun(op.runId);
@@ -62,33 +143,12 @@ export const postgresOperations = (input) => {
             WHERE run_id = ${op.runId} AND operation_key = ${op.operationKey}
           `;
             const prior = existing[0];
-            if (prior !== undefined) {
-                const consumed = yield* sql `
-              SELECT entry_id FROM tenetkit_run_steering
-              WHERE run_id = ${op.runId} AND consumed_operation_id = ${prior.operation_id}
-              ORDER BY sequence
-            `;
-                const retried = op.steeringEntryIds ?? [];
-                if (consumed.length !== retried.length ||
-                    consumed.some((entry, index) => entry.entry_id !== retried[index])) {
-                    return yield* RuntimeUnavailable.make({ message: "steering consumption does not match operation" });
-                }
-                return toOperationRecord(prior);
-            }
+            if (prior !== undefined)
+                return yield* existingOperation(op, prior);
             if (loaded.cancellationRequested) {
                 return yield* RuntimeUnavailable.make({ message: `run ${loaded.runId} is cancelling` });
             }
-            const steeringEntryIds = op.steeringEntryIds ?? [];
-            const pending = yield* sql `
-            SELECT entry_id FROM tenetkit_run_steering
-            WHERE run_id = ${op.runId} AND consumed_operation_id IS NULL AND discarded_reason IS NULL
-            ORDER BY sequence
-          `;
-            const selected = pending.slice(0, steeringEntryIds.length);
-            if (selected.length !== steeringEntryIds.length ||
-                selected.some((entry, index) => entry.entry_id !== steeringEntryIds[index])) {
-                return yield* RuntimeUnavailable.make({ message: "steering entries are not the pending prefix" });
-            }
+            const steeringEntryIds = yield* verifyPendingSteering(op);
             const operationId = yield* nextId("op");
             const executableRef = yield* Effect.try({
                 try: () => checkpointRef(loaded.executableRef, loaded.executableManifest, op.checkpoint),
@@ -165,40 +225,10 @@ export const postgresOperations = (input) => {
             const row = existing[0];
             if (row === undefined)
                 return yield* RuntimeUnavailable.make({ message: "operation missing" });
-            const current = toOperationRecord(row);
-            if (row.status === "cancelling" ||
-                row.status === "cancelled" ||
-                row.status === "succeeded" ||
-                row.status === "failed" ||
-                row.status === "unknown") {
-                if (current.kind === "handoff" && current.status === "succeeded" && isHandoffCommit(current.result)) {
-                    if (op.outcome._tag !== "Succeeded" ||
-                        !sameHandoffCommit(current.result, op.outcome.value) ||
-                        !sameHandoffCheckpoint(loaded.driverCheckpoint, op.checkpoint)) {
-                        return yield* RuntimeUnavailable.make({ message: "handoff operation has a divergent completion retry" });
-                    }
-                    const entry = handoffSessionEntry({
-                        sessionId: loaded.message.sessionId,
-                        operationKey: current.operationKey,
-                        value: op.outcome.value,
-                    });
-                    if (Schema.is(RuntimeUnavailable)(entry))
-                        return yield* entry;
-                    yield* verifyHandoffSessionEntry(entry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
-                }
-                return current;
-            }
-            for (const entryId of new Set(op.steeringEntryIds ?? [])) {
-                const rows = yield* sql `
-              SELECT consumed_operation_id FROM tenetkit_run_steering
-              WHERE run_id = ${op.runId} AND entry_id = ${entryId}
-            `;
-                if (rows[0]?.consumed_operation_id !== op.operationId) {
-                    return yield* RuntimeUnavailable.make({
-                        message: `steering entry ${entryId} does not belong to operation`,
-                    });
-                }
+            if (isCompletedOperationStatus(row.status)) {
+                return yield* verifyCompletedOperation(op, loaded, row);
             }
+            yield* verifyOperationSteering(op);
             const executableRef = yield* Effect.try({
                 try: () => checkpointRef(loaded.executableRef, loaded.executableManifest, op.checkpoint),
                 catch: (error) => RuntimeUnavailable.make({ message: String(error) }),
@@ -213,29 +243,7 @@ export const postgresOperations = (input) => {
                     return yield* entry;
                 yield* appendHandoffSessionEntry(entry).pipe(Effect.mapError((error) => RuntimeUnavailable.make({ message: error.message })));
             }
-            if (op.outcome._tag === "Succeeded") {
-                yield* sql `
-              UPDATE tenetkit_run_operations
-              SET status = 'succeeded', result_json = ${encodeJsonValue(op.outcome.value)}, finished_at = NOW()
-              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
-                AND status IN ('requested', 'running')
-            `;
-            }
-            else if (op.outcome._tag === "Failed") {
-                yield* sql `
-              UPDATE tenetkit_run_operations
-              SET status = 'failed', error_json = ${encodeJsonValue(op.outcome.error)}, finished_at = NOW()
-              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
-                AND status IN ('requested', 'running')
-            `;
-            }
-            else {
-                yield* sql `
-              UPDATE tenetkit_run_operations SET status = 'unknown', finished_at = NOW()
-              WHERE run_id = ${op.runId} AND operation_id = ${op.operationId}
-                AND status IN ('requested', 'running')
-            `;
-            }
+            yield* persistOperationOutcome(op);
             yield* sql `
             UPDATE tenetkit_runs SET
               driver_checkpoint_json = COALESCE(${op.checkpoint === undefined ? null : encodeJson(ExecutionCheckpoint, op.checkpoint)}, driver_checkpoint_json),
@@ -348,7 +356,7 @@ export const postgresOperations = (input) => {
             SELECT COUNT(*)::int AS unresolved FROM tenetkit_run_operations
             WHERE run_id = ${op.runId} AND status = 'unknown'
           `;
-            const runStatus = Number(unresolved[0]?.unresolved ?? 0) > 0
+            const runStatus = (unresolved[0]?.unresolved ?? 0) > 0
                 ? sql `'needs-resolution'`
                 : sql `CASE WHEN cancellation_requested THEN 'cancelling' ELSE 'queued' END`;
             yield* sql `

package/dist/postgres/{store-program.d.ts → store/program.d.ts}

@@ -2,9 +2,9 @@ import { Effect } from "effect";
 import type { PgClient } from "@effect/sql-pg";
 import { SqlClient } from "effect/unstable/sql";
 import { RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
-import type { Interface as RunStore } from "tenetkit/runtime/driver/run-store";
+import type { Interface as RunStore } from "tenetkit/runtime/driver/run/store";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/sql-effect";
+import type { WithoutSqlError } from "tenetkit/runtime/driver/sql/effect";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 type SqlR = SqlClient.SqlClient | PgClient.PgClient;
 export type Run = <A, E>(effect: Effect.Effect<A, E | SqlError, SqlR>) => Effect.Effect<A, WithoutSqlError<E | SqlError> | RuntimeUnavailable>;

package/dist/postgres/{store-program.js → store/program.js}

@@ -2,11 +2,11 @@ import { Effect } from "effect";
 import { ProgramCapabilities } from "tenetkit";
 import { SqlClient } from "effect/unstable/sql";
 import { RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
-import { requireExecutionClaim } from "tenetkit/runtime/driver/sql/store-execution";
-import { loadProgramState, getProgramOperation, reserveProgramOperation, admitProgramAgents, commitProgramLog, settleProgramOperation, suspendProgramOperation, startProgramOperation, } from "tenetkit/runtime/driver/sql/store-program";
-import { completeRun, requireRun } from "./pg-helpers.js";
-import { suspend } from "./store-suspend.js";
-import { admitProgramChild } from "tenetkit/runtime/driver/sql/store-admit";
+import { requireExecutionClaim } from "tenetkit/runtime/driver/sql/store/execution";
+import { loadProgramState, getProgramOperation, reserveProgramOperation, admitProgramAgents, commitProgramLog, settleProgramOperation, suspendProgramOperation, startProgramOperation, } from "tenetkit/runtime/driver/sql/store/program";
+import { completeRun, requireRun } from "./runtime.js";
+import { suspend } from "./suspend.js";
+import { admitProgramChild } from "tenetkit/runtime/driver/sql/store/admit";
 export const programStoreMethods = (input) => {
     const fenced = (claim, effect) => input.run(input.sql `SELECT run_id FROM tenetkit_runs WHERE run_id = ${claim.runId} FOR UPDATE`.pipe(Effect.andThen(requireExecutionClaim(claim)), Effect.andThen(effect)));
     return {

package/dist/postgres/{pg-helpers.d.ts → store/runtime.d.ts}

@@ -2,16 +2,16 @@ import { Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import type { SqlError } from "effect/unstable/sql/SqlError";
 import { PgClient } from "@effect/sql-pg";
-import { type RunEvent } from "tenetkit/runtime/driver/run-event";
-import type { ExecutableManifest, ExecutableRef } from "tenetkit/runtime/driver/executable-manifest";
-import type { Message } from "tenetkit/runtime/driver/message";
+import { type RunEvent } from "tenetkit/runtime/driver/run/event";
+import type { ExecutableManifest, ExecutableRef } from "tenetkit/runtime/driver/executable/manifest";
+import type { Message } from "tenetkit/runtime/driver/messaging/message";
 import { type RunStatus } from "tenetkit/runtime/driver/run";
-import { decodeMessage, decodeQueue, encodeQueue } from "tenetkit/runtime/driver/sql/codecs";
+import { decodeMessage, decodeQueue, encodeQueue } from "tenetkit/runtime/driver/sql/codec/codecs";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
-import type { DecodedRun } from "tenetkit/runtime/driver/sql/rows";
-import type { EmittableAgentLoopEvent } from "tenetkit/runtime/driver/agent-event";
-import { type ExecutionClaim } from "tenetkit/runtime/driver/run-store";
-import type { ExecutionResult } from "tenetkit/runtime/driver/execution-state";
+import type { DecodedRun } from "tenetkit/runtime/driver/sql/codec/rows";
+import type { EmittableAgentLoopEvent } from "tenetkit/runtime/driver/execution/agent/event";
+import { type ExecutionClaim } from "tenetkit/runtime/driver/run/store";
+import type { ExecutionResult } from "tenetkit/runtime/driver/execution/state";
 import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
 import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
 type StoreError = RuntimeUnavailable | SqlError;
@@ -26,9 +26,14 @@ type AgentEventError = RunNotFound | RunTerminal | StoreError | StaleClaim;
 type AgentEventEffect = Effect.Effect<undefined, AgentEventError, SqlClient.SqlClient>;
 type CompleteRunEffect = Effect.Effect<undefined, RunTerminal | StoreError, SqlClient.SqlClient>;
 type SettleParentEffect = Effect.Effect<void, StoreError, SqlClient.SqlClient | PgClient.PgClient>;
-export type EventPartial = {
+type EventField = RunEvent extends RunEvent ? unknown : never;
+type AppendInput = object & {
     readonly _tag: string;
-} & Record<string, unknown>;
+};
+export interface EventPartial {
+    readonly _tag: string;
+    readonly [key: string]: EventField;
+}
 export declare const loadRun: (runId: string) => Effect.Effect<DecodedRun | undefined, RuntimeUnavailable | SqlError, SqlClient.SqlClient>;
 export declare const requireRun: (runId: string) => Effect.Effect<DecodedRun, RunNotFound | RuntimeUnavailable | SqlError, SqlClient.SqlClient>;
 export declare const emitAgentEvent: {
@@ -45,7 +50,8 @@ export declare const loadEventsAfter: {
 };
 export declare const allocateSequence: (runId: string) => Effect.Effect<number, SqlError, SqlClient.SqlClient>;
 export declare const appendEvent: {
-    (run: DecodedRun, partial: EventPartial, nextStatus?: RunStatus): (hub: EventHub) => RunEventEffect;
+    <Partial extends AppendInput>(run: DecodedRun, partial: Partial, nextStatus?: RunStatus): (hub: EventHub) => RunEventEffect;
+    <Partial extends AppendInput>(hub: EventHub, run: DecodedRun, partial: Partial, nextStatus?: RunStatus): RunEventEffect;
     (hub: EventHub, run: DecodedRun, partial: EventPartial, nextStatus?: RunStatus): RunEventEffect;
 };
 export declare const promoteHead: {
@@ -77,7 +83,7 @@ export declare const insertRun: (input: {
     readonly executableManifest: ExecutableManifest;
     readonly rootRunId: string;
     readonly depth: number;
-    readonly treePolicy: import("tenetkit/runtime/driver/tree-policy").TreePolicy;
+    readonly treePolicy: import("tenetkit/runtime/driver/tree/policy").TreePolicy;
     readonly parentRunId?: string;
     readonly invocationId?: string;
     readonly acceptedSequence: number;

package/dist/postgres/{pg-helpers.js → store/runtime.js}

@@ -1,19 +1,37 @@
 import { Effect, Function } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { PgClient } from "@effect/sql-pg";
-import { eventIdFor } from "tenetkit/runtime/driver/run-event";
+import { eventIdFor } from "tenetkit/runtime/driver/run/event";
 import { isTerminal } from "tenetkit/runtime/driver/run";
-import { StringArray, decodeMessage, decodeQueue, encodeExecutableManifest, encodeExecutableRef, encodeEvent, encodeJson, encodeMessage, encodeQueue, } from "tenetkit/runtime/driver/sql/codecs";
-import { reconcileFanOutWith } from "tenetkit/runtime/driver/sql/store-fan-out";
-import { decodePersistedEvents, decodeRunEffect, nowIso } from "tenetkit/runtime/driver/sql/store-helpers";
-import { NOTIFY_CHANNEL } from "./schema.js";
-import { PendingRunOutcome } from "tenetkit/runtime/driver/run-store";
+import { StringArray, decodeMessage, decodeEvent, decodeQueue, encodeExecutableManifest, encodeExecutableRef, encodeEvent, encodeJson, encodeMessage, encodeQueue, } from "tenetkit/runtime/driver/sql/codec/codecs";
+import { reconcileFanOutWith } from "tenetkit/runtime/driver/sql/store/fan-out/service";
+import { decodePersistedEvents, decodeRunEffect, nowIso } from "tenetkit/runtime/driver/sql/store/statements";
+import { NOTIFY_CHANNEL } from "../schema.js";
+import { PendingRunOutcome } from "tenetkit/runtime/driver/run/store";
 import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
 import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
 import { admitChildSettlementFromEventId } from "tenetkit/runtime/driver/sql/settlement-notifications";
-import { discardPendingSteering } from "tenetkit/runtime/driver/sql/store-steering-disposition";
-import { hasPendingOperationCancellation, hasUnsettledChild, loadTerminalEvent, reconcileChildWaitWith, } from "tenetkit/runtime/driver/sql/store-child-settlement";
-import { appendTerminalToolResultsForEvent } from "tenetkit/runtime/driver/sql/session-terminalization";
+import { discardPendingSteering } from "tenetkit/runtime/driver/sql/store/steering/disposition";
+import { hasPendingOperationCancellation, hasUnsettledChild, loadTerminalEvent, reconcileChildWaitWith, } from "tenetkit/runtime/driver/sql/store/child/settlement";
+import { appendTerminalToolResultsForEvent } from "tenetkit/runtime/driver/sql/session/terminalization";
+const isTerminalEvent = (event) => event._tag === "RunCompleted" || event._tag === "RunFailed" || event._tag === "RunCancelled";
+const makeEvent = (run, partial, sequence, occurredAt) => {
+    const base = {
+        specVersion: "1",
+        eventId: eventIdFor(run.runId, sequence),
+        runId: run.runId,
+        sequence,
+        executableRef: run.executableRef,
+        rootRunId: run.rootRunId,
+        depth: run.depth,
+        occurredAt,
+    };
+    Object.assign(base, run.parentRunId === undefined ? {} : { parentRunId: run.parentRunId });
+    Object.assign(base, run.message.causationId === undefined ? {} : { causationId: run.message.causationId });
+    Object.assign(base, run.message.correlationId === undefined ? {} : { correlationId: run.message.correlationId });
+    Object.assign(base, run.attempt > 0 ? { attemptId: `${run.runId}:attempt:${run.attempt}` } : {});
+    return decodeEvent(JSON.stringify(Object.assign(base, partial)));
+};
 export const loadRun = (runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     const rows = yield* sql `SELECT * FROM tenetkit_runs WHERE run_id = ${runId}`;
@@ -61,7 +79,7 @@ export const allocateSequence = (runId) => Effect.gen(function* () {
       WHERE run_id = ${runId}
       RETURNING last_sequence
     `;
-    return Number(rows[0].last_sequence);
+    return rows[0].last_sequence;
 });
 export const appendEvent = Function.dual((args) => args.length >= 4 || (args.length === 3 && !("runId" in args[0])), (_hub, run, partial, nextStatus) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -74,21 +92,7 @@ export const appendEvent = Function.dual((args) => args.length >= 4 || (args.len
     yield* appendTerminalToolResultsForEvent({ run, event: partial });
     const sequence = yield* allocateSequence(run.runId);
     const occurredAt = yield* nowIso;
-    const event = {
-        specVersion: "1",
-        eventId: eventIdFor(run.runId, sequence),
-        runId: run.runId,
-        sequence,
-        executableRef: run.executableRef,
-        rootRunId: run.rootRunId,
-        depth: run.depth,
-        occurredAt,
-        ...(run.parentRunId === undefined ? {} : { parentRunId: run.parentRunId }),
-        ...(run.message.causationId === undefined ? {} : { causationId: run.message.causationId }),
-        ...(run.message.correlationId === undefined ? {} : { correlationId: run.message.correlationId }),
-        ...(run.attempt > 0 ? { attemptId: `${run.runId}:attempt:${run.attempt}` } : {}),
-        ...partial,
-    };
+    const event = makeEvent(run, partial, sequence, occurredAt);
     yield* sql `
       INSERT INTO tenetkit_run_events (run_id, sequence, event_id, event_json)
       VALUES (${run.runId}, ${sequence}, ${event.eventId}, ${encodeEvent(event)})
@@ -99,23 +103,19 @@ export const appendEvent = Function.dual((args) => args.length >= 4 || (args.len
     `)[0];
     yield* sql `
       INSERT INTO tenetkit_tree_event_index (root_run_id, position, run_id, run_sequence, event_id)
-      VALUES (${run.rootRunId}, ${Number(treeRoot.last_position)}, ${run.runId}, ${sequence}, ${event.eventId})
+      VALUES (${run.rootRunId}, ${treeRoot.last_position}, ${run.runId}, ${sequence}, ${event.eventId})
     `;
     const status = nextStatus ?? run.status;
-    const activeWaitId = event._tag === "RunWaiting"
-        ? event.wait.waitId
-        : event._tag === "RunResumed"
-            ? null
-            : (run.activeWaitId ?? null);
-    const terminalEventId = event._tag === "RunCompleted" || event._tag === "RunFailed" || event._tag === "RunCancelled"
-        ? event.eventId
-        : (run.terminalEventId ?? null);
+    let activeWaitId = run.activeWaitId ?? null;
+    if (event._tag === "RunWaiting")
+        activeWaitId = event.wait.waitId;
+    if (event._tag === "RunResumed")
+        activeWaitId = null;
+    const terminalEventId = isTerminalEvent(event) ? event.eventId : (run.terminalEventId ?? null);
     const cancellationRequested = event._tag === "RunCancellationRequested" || run.cancellationRequested;
-    const cancelReason = event._tag === "RunCancellationRequested" && "reason" in event && typeof event.reason === "string"
-        ? event.reason
-        : (run.cancelReason ?? null);
+    const cancelReason = event._tag === "RunCancellationRequested" ? (event.reason ?? null) : (run.cancelReason ?? null);
     const attempt = event._tag === "RunAttemptStarted" ? event.attempt : run.attempt;
-    const terminalPartial = event._tag === "RunCompleted" || event._tag === "RunFailed" || event._tag === "RunCancelled";
+    const terminalPartial = isTerminalEvent(event);
     if (terminalPartial) {
         yield* sql `
         UPDATE tenetkit_runs SET
@@ -171,9 +171,7 @@ export const promoteHead = Function.dual(3, (hub, address, sessionId) => Effect.
         WHERE address = ${address} AND session_id = ${sessionId}
       `;
     }
-    const head = yield* loadRun(headId);
-    if (head === undefined || head.status !== "queued" || head.cancellationRequested)
-        return;
+    yield* loadRun(headId);
 }));
 export const removeFromLane = Function.dual(3, (address, sessionId, runId) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -217,7 +215,7 @@ export const completeRun = Function.dual(3, (hub, run, result) => Effect.gen(fun
         `;
             return;
         }
-        const event = yield* appendEvent(hub, run, { _tag: "RunCancelled", ...(run.cancelReason === undefined ? {} : { reason: run.cancelReason }) }, "cancelled");
+        const event = yield* appendEvent(hub, run, { _tag: "RunCancelled", ...(run.cancelReason === undefined ? undefined : { reason: run.cancelReason }) }, "cancelled");
         const settled = (yield* loadRun(run.runId));
         yield* settleParent(hub, settled, event.eventId);
         yield* afterTerminal(hub, settled);
@@ -292,10 +290,13 @@ export const settleParent = Function.dual(3, (hub, child, terminalEventId) => Ef
             yield* sql `UPDATE tenetkit_runs SET attempt_fence = ${attempt} WHERE run_id = ${parent.runId}`;
             yield* appendEvent(hub, { ...currentParent, attempt }, { _tag: "RunAttemptStarted", attempt }, "running");
         }
-        return;
     }
-    if (currentParent?.status !== "cancelling" || currentParent.ownerWorkerId !== undefined)
-        return;
+    else if (currentParent?.status === "cancelling" && currentParent.ownerWorkerId === undefined) {
+        yield* settleCancelledParent(hub, currentParent);
+    }
+}));
+const settleCancelledParent = (hub, parent) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
     const running = yield* sql `
       SELECT fan_out_id FROM tenetkit_fan_outs WHERE parent_run_id = ${parent.runId} AND status = 'running' LIMIT 1
     `;
@@ -305,14 +306,14 @@ export const settleParent = Function.dual(3, (hub, child, terminalEventId) => Ef
         return;
     if (yield* hasUnsettledChild(parent.runId))
         return;
-    const cancelled = yield* appendEvent(hub, currentParent, {
+    const cancelled = yield* appendEvent(hub, parent, {
         _tag: "RunCancelled",
-        ...(currentParent.cancelReason === undefined ? {} : { reason: currentParent.cancelReason }),
+        ...(parent.cancelReason === undefined ? undefined : { reason: parent.cancelReason }),
     }, "cancelled");
     const settledParent = (yield* loadRun(parent.runId));
     yield* settleParent(hub, settledParent, cancelled.eventId);
     yield* afterTerminal(hub, settledParent);
-}));
+});
 export const insertRun = (input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* sql `

package/dist/postgres/{store-suspend.d.ts → store/suspend.d.ts}

@@ -3,7 +3,7 @@ import { SqlClient } from "effect/unstable/sql";
 import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
 import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
 import type { SqlError } from "effect/unstable/sql/SqlError";
-import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run-store";
+import type { Interface as RunStoreInterface } from "tenetkit/runtime/driver/run/store";
 import type { EventHub } from "tenetkit/runtime/driver/sql/subscribers";
 type SuspendEffect = Effect.Effect<undefined, RunNotFound | RunTerminal | RuntimeUnavailable | SqlError | StaleClaim, SqlClient.SqlClient>;
 export declare const suspend: {

package/dist/postgres/{store-suspend.js → store/suspend.js}

@@ -2,18 +2,18 @@ import { Effect, Function, Option } from "effect";
 import { SqlClient } from "effect/unstable/sql";
 import { RunNotFound, RunTerminal, RuntimeUnavailable } from "tenetkit/runtime/driver/errors";
 import { StaleClaim } from "tenetkit/runtime/driver/sql/errors";
-import { checkpointRef } from "tenetkit/runtime/driver/executable-manifest";
+import { checkpointRef } from "tenetkit/runtime/driver/executable/manifest";
 import { isTerminal } from "tenetkit/runtime/driver/run";
-import { encodeContinuation } from "tenetkit/runtime/driver/steering";
-import { encodeExecutableRef, encodeJson } from "tenetkit/runtime/driver/sql/codecs";
-import { encodeReason, WaitResolution } from "tenetkit/runtime/driver/run-wait";
-import { lockRun } from "./locks.js";
-import { appendEvent, requireRun } from "./pg-helpers.js";
-import { requireExecutionClaim } from "tenetkit/runtime/driver/sql/store-execution";
-import { groupIdFromSuspension, resultFromInspection } from "tenetkit/runtime/driver/child-group";
-import { inspectFanOut } from "tenetkit/runtime/driver/sql/store-fan-out";
-import { ExecutionCheckpoint, ExecutionSuspension } from "tenetkit/runtime/driver/execution-state";
-import { loadTerminalEvent, reconcileChildWaitWith } from "tenetkit/runtime/driver/sql/store-child-settlement";
+import { encodeContinuation } from "tenetkit/runtime/driver/run/steering";
+import { encodeExecutableRef, encodeJson } from "tenetkit/runtime/driver/sql/codec/codecs";
+import { encodeReason, WaitResolution } from "tenetkit/runtime/driver/run/wait";
+import { lockRun } from "../runs/locks.js";
+import { appendEvent, requireRun } from "./runtime.js";
+import { requireExecutionClaim } from "tenetkit/runtime/driver/sql/store/execution";
+import { groupIdFromSuspension, resultFromInspection } from "tenetkit/runtime/driver/child/group";
+import { inspectFanOut } from "tenetkit/runtime/driver/sql/store/fan-out/service";
+import { ExecutionCheckpoint, ExecutionSuspension } from "tenetkit/runtime/driver/execution/state";
+import { loadTerminalEvent, reconcileChildWaitWith } from "tenetkit/runtime/driver/sql/store/child/settlement";
 export const suspend = Function.dual(2, (hub, input) => Effect.gen(function* () {
     const sql = yield* SqlClient.SqlClient;
     yield* lockRun(input.runId);
@@ -49,9 +49,9 @@ export const suspend = Function.dual(2, (hub, input) => Effect.gen(function* ()
         status = 'open', reason = EXCLUDED.reason, response_json = NULL, opened_at = EXCLUDED.opened_at, closed_at = NULL
     `;
     yield* appendEvent(hub, loaded, { _tag: "RunWaiting", wait: input.wait }, "waiting");
-    const child = typeof input.suspension.token === "string"
-        ? yield* requireRun(input.suspension.token).pipe(Effect.option)
-        : Option.none();
+    const child = input.suspension.token === undefined
+        ? Option.none()
+        : yield* requireRun(input.suspension.token).pipe(Effect.option);
     if (child._tag === "Some" && child.value.terminalEventId !== undefined) {
         const terminalEvent = yield* loadTerminalEvent(child.value.terminalEventId);
         if (terminalEvent !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.40.1",
+  "version": "0.41.2",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@effect/sql-pg": "4.0.0-rc.111",
-    "tenetkit": "0.40.1"
+    "tenetkit": "0.41.2"
   },
   "devDependencies": {
     "@effect/vitest": "4.0.0-rc.111",