@shivaedev/work-fleet 0.1.1 → 0.2.0

package/dist/storage/shapeV12.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapeV12.d.ts","sourceRoot":"","sources":["../../src/storage/shapeV12.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAD2B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAL,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAIC,QAAQ;;;;;CAEpC,CAAC"}

package/dist/storage/shapeV12.js

@@ -0,0 +1,10 @@
+import { attemptV12 } from "#storage/attemptV12.ts";
+import { cycleV12 } from "#storage/cycleV12.ts";
+const cycle = { ...cycleV12.fields, attempts: { array: attemptV12 } };
+export const shapeV12 = {
+    fields: {
+        ...cycle,
+        history: { array: { fields: { ...cycle, archivedAt: "number" } } },
+    },
+};
+//# sourceMappingURL=shapeV12.js.map

package/dist/storage/shapeV12.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapeV12.js","sourceRoot":"","sources":["../../src/storage/shapeV12.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD,MAAM,KAAK,GAAG,EAAE,GAAG,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,CAAC;AACtE,MAAM,CAAC,MAAM,QAAQ,GAAG;IACvB,MAAM,EAAE;QACP,GAAG,KAAK;QACR,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE;KAClE;CACwB,CAAC"}

package/dist/storage/textRecordValue.d.ts

@@ -0,0 +1,3 @@
+import { Effect, Schema } from "effect";
+export declare const textRecordValue: (row: Readonly<Record<string, unknown>>, structured: readonly string[]) => Effect.Effect<Record<string, unknown>, Schema.SchemaError, never>;
+//# sourceMappingURL=textRecordValue.d.ts.map

package/dist/storage/textRecordValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textRecordValue.d.ts","sourceRoot":"","sources":["../../src/storage/textRecordValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGxC,eAAO,MAAM,eAAe,8IAY1B,CAAC"}

package/dist/storage/textRecordValue.js

@@ -0,0 +1,13 @@
+import { Effect, Schema } from "effect";
+import { legacyColumns } from "#storage/legacyColumns.ts";
+export const textRecordValue = Effect.fn("FleetStore.textRecordValue")(function* (row, structured) {
+    const value = {};
+    for (const name of Object.keys(legacyColumns)) {
+        const field = row[structured.includes(name) ? `legacy_${name}` : name];
+        if (field !== null) {
+            value[name] = structured.includes(name) ? yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(field) : field;
+        }
+    }
+    return value;
+});
+//# sourceMappingURL=textRecordValue.js.map

package/dist/storage/textRecordValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textRecordValue.js","sourceRoot":"","sources":["../../src/storage/textRecordValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,EAAE,CAAC,4BAA4B,CAAC,CAAC,QAAQ,CAAC,EAC/E,GAAsC,EACtC,UAA6B;IAE7B,MAAM,KAAK,GAA4B,EAAE,CAAC;IAC1C,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC;QAC/C,MAAM,KAAK,GAAG,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACvE,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACpB,KAAK,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACnI,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC,CAAC,CAAC"}

package/dist/storage/typedDecisionsV12.d.ts

@@ -0,0 +1,103 @@
+export declare const decisionV12: {
+    readonly fields: {
+        readonly attentionOwner: "string";
+        readonly boardAcknowledgementDisposition: "string";
+        readonly code: "string";
+        readonly id: "string";
+        readonly links: {
+            readonly array: "string";
+        };
+        readonly publicationWork: {
+            readonly fields: {
+                readonly approved: "boolean";
+                readonly areas: {
+                    readonly array: "string";
+                };
+                readonly context: "string";
+                readonly deliverable: "string";
+                readonly dependsOn: {
+                    readonly array: "string";
+                };
+                readonly revision: "string";
+                readonly sourcePath: "string";
+                readonly status: "string";
+                readonly workId: "string";
+            };
+        };
+        readonly published: {
+            readonly fields: {
+                readonly itemId: "string";
+                readonly questionId: "string";
+                readonly request: "string";
+                readonly revision: "string";
+                readonly sourcePath: "string";
+                readonly workId: "string";
+                readonly workRevision: "string";
+                readonly workSourcePath: "string";
+            };
+        };
+        readonly reason: "string";
+        readonly recommendation: "string";
+        readonly worker: {
+            readonly fields: {
+                readonly sessionId: "string";
+                readonly turnId: "string";
+            };
+        };
+    };
+};
+export declare const responsesV12: {
+    readonly array: {
+        readonly fields: {
+            readonly action: "string";
+            readonly boardAcknowledged: "boolean";
+            readonly boardAcknowledgementDisposition: "string";
+            readonly decisionId: "string";
+            readonly processedAt: "number";
+            readonly published: {
+                readonly fields: {
+                    readonly itemId: "string";
+                    readonly questionId: "string";
+                    readonly request: "string";
+                    readonly revision: "string";
+                    readonly sourcePath: "string";
+                    readonly workId: "string";
+                    readonly workRevision: "string";
+                    readonly workSourcePath: "string";
+                };
+            };
+            readonly questionId: "string";
+            readonly questionRevision: "string";
+            readonly responseId: "string";
+            readonly type: "string";
+        };
+    };
+};
+export declare const supersededDecisionsV12: {
+    readonly array: {
+        readonly fields: {
+            readonly boardAcknowledged: "boolean";
+            readonly boardAcknowledgementDisposition: "string";
+            readonly published: {
+                readonly fields: {
+                    readonly itemId: "string";
+                    readonly questionId: "string";
+                    readonly request: "string";
+                    readonly revision: "string";
+                    readonly sourcePath: "string";
+                    readonly workId: "string";
+                    readonly workRevision: "string";
+                    readonly workSourcePath: "string";
+                };
+            };
+            readonly reassignedTo: {
+                readonly fields: {
+                    readonly attentionOwner: "string";
+                    readonly decisionId: "string";
+                };
+            };
+            readonly supersededAt: "number";
+        };
+    };
+};
+//# sourceMappingURL=typedDecisionsV12.d.ts.map

package/dist/storage/typedDecisionsV12.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedDecisionsV12.d.ts","sourceRoot":"","sources":["../../src/storage/typedDecisionsV12.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;iBAEtB,cAAc,EAAE,QAAQ;iBACxB,+BAA+B,EAAE,QAAQ;iBACzC,IAAI,EAAE,QAAQ;iBACd,EAAE,EAAE,QAAQ;iBACZ,KAAK;qBAAI,KAAK,EAAE,QAAQ;;iBACxB,eAAe;qBACd,MAAM;yBACL,QAAQ,EAAE,SAAS;yBACnB,KAAK;6BAAI,KAAK,EAAE,QAAQ;;yBACxB,OAAO,EAAE,QAAQ;yBACjB,WAAW,EAAE,QAAQ;yBACrB,SAAS;6BAAI,KAAK,EAAE,QAAQ;;yBAC5B,QAAQ,EAAE,QAAQ;yBAClB,UAAU,EAAE,QAAQ;yBACpB,MAAM,EAAE,QAAQ;yBAChB,MAAM,EAAE,QAAQ;;;iBAGlB,SAAS;qBACR,MAAM;yBACL,MAAM,EAAE,QAAQ;yBAChB,UAAU,EAAE,QAAQ;yBACpB,OAAO,EAAE,QAAQ;yBACjB,QAAQ,EAAE,QAAQ;yBAClB,UAAU,EAAE,QAAQ;yBACpB,MAAM,EAAE,QAAQ;yBAChB,YAAY,EAAE,QAAQ;yBACtB,cAAc,EAAE,QAAQ;;;iBAG1B,MAAM,EAAE,QAAQ;iBAChB,cAAc,EAAE,QAAQ;iBACxB,MAAM;qBACL,MAAM;yBACL,SAAS,EAAE,QAAQ;yBACnB,MAAM,EAAE,QAAQ;;;;CAIM,CAAC;AAE3B,eAAO,MAAM,YAAY;;iBAEvB,MAAM;qBACL,MAAM,EAAE,QAAQ;qBAChB,iBAAiB,EAAE,SAAS;qBAC5B,+BAA+B,EAAE,QAAQ;qBACzC,UAAU,EAAE,QAAQ;qBACpB,WAAW,EAAE,QAAQ;qBACrB,SAAS;yBACR,MAAM;6BACL,MAAM,EAAE,QAAQ;6BAChB,UAAU,EAAE,QAAQ;6BACpB,OAAO,EAAE,QAAQ;6BACjB,QAAQ,EAAE,QAAQ;6BAClB,UAAU,EAAE,QAAQ;6BACpB,MAAM,EAAE,QAAQ;6BAChB,YAAY,EAAE,QAAQ;6BACtB,cAAc,EAAE,QAAQ;;;qBAG1B,UAAU,EAAE,QAAQ;qBACpB,gBAAgB,EAAE,QAAQ;qBAC1B,UAAU,EAAE,QAAQ;qBACpB,IAAI,EAAE,QAAQ;;;CAGS,CAAC;AAE3B,eAAO,MAAM,sBAAsB;;iBAEjC,MAAM;qBACL,iBAAiB,EAAE,SAAS;qBAC5B,+BAA+B,EAAE,QAAQ;qBACzC,SAAS;yBACR,MAAM;6BACL,MAAM,EAAE,QAAQ;6BAChB,UAAU,EAAE,QAAQ;6BACpB,OAAO,EAAE,QAAQ;6BACjB,QAAQ,EAAE,QAAQ;6BAClB,UAAU,EAAE,QAAQ;6BACpB,MAAM,EAAE,QAAQ;6BAChB,YAAY,EAAE,QAAQ;6BACtB,cAAc,EAAE,QAAQ;;;qBAG1B,YAAY;yBACX,MAAM;6BACL,cAAc,EAAE,QAAQ;6BACxB,UAAU,EAAE,QAAQ;;;qBAGtB,YAAY,EAAE,QAAQ;;;CAGC,CAAC"}

package/dist/storage/typedDecisionsV12.js

@@ -0,0 +1,97 @@
+export const decisionV12 = {
+    fields: {
+        attentionOwner: "string",
+        boardAcknowledgementDisposition: "string",
+        code: "string",
+        id: "string",
+        links: { array: "string" },
+        publicationWork: {
+            fields: {
+                approved: "boolean",
+                areas: { array: "string" },
+                context: "string",
+                deliverable: "string",
+                dependsOn: { array: "string" },
+                revision: "string",
+                sourcePath: "string",
+                status: "string",
+                workId: "string",
+            },
+        },
+        published: {
+            fields: {
+                itemId: "string",
+                questionId: "string",
+                request: "string",
+                revision: "string",
+                sourcePath: "string",
+                workId: "string",
+                workRevision: "string",
+                workSourcePath: "string",
+            },
+        },
+        reason: "string",
+        recommendation: "string",
+        worker: {
+            fields: {
+                sessionId: "string",
+                turnId: "string",
+            },
+        },
+    },
+};
+export const responsesV12 = {
+    array: {
+        fields: {
+            action: "string",
+            boardAcknowledged: "boolean",
+            boardAcknowledgementDisposition: "string",
+            decisionId: "string",
+            processedAt: "number",
+            published: {
+                fields: {
+                    itemId: "string",
+                    questionId: "string",
+                    request: "string",
+                    revision: "string",
+                    sourcePath: "string",
+                    workId: "string",
+                    workRevision: "string",
+                    workSourcePath: "string",
+                },
+            },
+            questionId: "string",
+            questionRevision: "string",
+            responseId: "string",
+            type: "string",
+        },
+    },
+};
+export const supersededDecisionsV12 = {
+    array: {
+        fields: {
+            boardAcknowledged: "boolean",
+            boardAcknowledgementDisposition: "string",
+            published: {
+                fields: {
+                    itemId: "string",
+                    questionId: "string",
+                    request: "string",
+                    revision: "string",
+                    sourcePath: "string",
+                    workId: "string",
+                    workRevision: "string",
+                    workSourcePath: "string",
+                },
+            },
+            reassignedTo: {
+                fields: {
+                    attentionOwner: "string",
+                    decisionId: "string",
+                },
+            },
+            supersededAt: "number",
+        },
+    },
+};
+//# sourceMappingURL=typedDecisionsV12.js.map

package/dist/storage/typedDecisionsV12.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedDecisionsV12.js","sourceRoot":"","sources":["../../src/storage/typedDecisionsV12.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAG;IAC1B,MAAM,EAAE;QACP,cAAc,EAAE,QAAQ;QACxB,+BAA+B,EAAE,QAAQ;QACzC,IAAI,EAAE,QAAQ;QACd,EAAE,EAAE,QAAQ;QACZ,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;QAC1B,eAAe,EAAE;YAChB,MAAM,EAAE;gBACP,QAAQ,EAAE,SAAS;gBACnB,KAAK,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;gBAC1B,OAAO,EAAE,QAAQ;gBACjB,WAAW,EAAE,QAAQ;gBACrB,SAAS,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE;gBAC9B,QAAQ,EAAE,QAAQ;gBAClB,UAAU,EAAE,QAAQ;gBACpB,MAAM,EAAE,QAAQ;gBAChB,MAAM,EAAE,QAAQ;aAChB;SACD;QACD,SAAS,EAAE;YACV,MAAM,EAAE;gBACP,MAAM,EAAE,QAAQ;gBAChB,UAAU,EAAE,QAAQ;gBACpB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,QAAQ;gBAClB,UAAU,EAAE,QAAQ;gBACpB,MAAM,EAAE,QAAQ;gBAChB,YAAY,EAAE,QAAQ;gBACtB,cAAc,EAAE,QAAQ;aACxB;SACD;QACD,MAAM,EAAE,QAAQ;QAChB,cAAc,EAAE,QAAQ;QACxB,MAAM,EAAE;YACP,MAAM,EAAE;gBACP,SAAS,EAAE,QAAQ;gBACnB,MAAM,EAAE,QAAQ;aAChB;SACD;KACD;CACwB,CAAC;AAE3B,MAAM,CAAC,MAAM,YAAY,GAAG;IAC3B,KAAK,EAAE;QACN,MAAM,EAAE;YACP,MAAM,EAAE,QAAQ;YAChB,iBAAiB,EAAE,SAAS;YAC5B,+BAA+B,EAAE,QAAQ;YACzC,UAAU,EAAE,QAAQ;YACpB,WAAW,EAAE,QAAQ;YACrB,SAAS,EAAE;gBACV,MAAM,EAAE;oBACP,MAAM,EAAE,QAAQ;oBAChB,UAAU,EAAE,QAAQ;oBACpB,OAAO,EAAE,QAAQ;oBACjB,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,QAAQ;oBACpB,MAAM,EAAE,QAAQ;oBAChB,YAAY,EAAE,QAAQ;oBACtB,cAAc,EAAE,QAAQ;iBACxB;aACD;YACD,UAAU,EAAE,QAAQ;YACpB,gBAAgB,EAAE,QAAQ;YAC1B,UAAU,EAAE,QAAQ;YACpB,IAAI,EAAE,QAAQ;SACd;KACD;CACwB,CAAC;AAE3B,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACrC,KAAK,EAAE;QACN,MAAM,EAAE;YACP,iBAAiB,EAAE,SAAS;YAC5B,+BAA+B,EAAE,QAAQ;YACzC,SAAS,EAAE;gBACV,MAAM,EAAE;oBACP,MAAM,EAAE,QAAQ;oBAChB,UAAU,EAAE,QAAQ;oBACpB,OAAO,EAAE,QAAQ;oBACjB,QAAQ,EAAE,QAAQ;oBAClB,UAAU,EAAE,QAAQ;oBACpB,MAAM,EAAE,QAAQ;oBAChB,YAAY,EAAE,QAAQ;oBACtB,cAAc,EAAE,QAAQ;iBACxB;aACD;YACD,YAAY,EAAE;gBACb,MAAM,EAAE;oBACP,cAAc,EAAE,QAAQ;oBACxB,UAAU,EAAE,QAAQ;iBACpB;aACD;YACD,YAAY,EAAE,QAAQ;SACtB;KACD;CACwB,CAAC"}

package/dist/storage/typedTables.d.ts

@@ -0,0 +1,4 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+export declare const typedTables: (namespace: string) => Effect.Effect<void, Schema.SchemaError | import("effect/sql/SqlError").SqlError, SqlClient.SqlClient>;
+//# sourceMappingURL=typedTables.d.ts.map

package/dist/storage/typedTables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedTables.d.ts","sourceRoot":"","sources":["../../src/storage/typedTables.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AASvC,eAAO,MAAM,WAAW,8HA4BtB,CAAC"}

package/dist/storage/typedTables.js

@@ -0,0 +1,39 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { createCollections } from "#storage/createCollections.ts";
+import { legacyColumns } from "#storage/legacyColumns.ts";
+import { modelFromColumns } from "#storage/model.ts";
+import { inputColumns, makeRecordChildren } from "#storage/recordChildren.ts";
+import { shapeColumns, sqlTypes } from "#storage/recordShape.ts";
+import { shapeV12 } from "#storage/shapeV12.ts";
+import { textRecordValue } from "#storage/textRecordValue.ts";
+export const typedTables = Effect.fn("FleetStore.typedTables")(function* (namespace) {
+    const sql = yield* SqlClient.SqlClient;
+    const table = `${namespace}_records`;
+    const structured = Object.entries(legacyColumns)
+        .filter(([_name, kind]) => kind === "json")
+        .map(([name]) => name);
+    for (const name of structured) {
+        yield* sql `alter table ${sql(table)} rename column ${sql(name)} to ${sql(`legacy_${name}`)}`;
+    }
+    const columns = shapeColumns(shapeV12);
+    for (const [name, kind] of Object.entries(columns)) {
+        if (!(name in legacyColumns) || structured.includes(name)) {
+            yield* sql `alter table ${sql(table)} add column ${sql(name)} ${sql.literal(sqlTypes[kind])}`;
+        }
+    }
+    yield* createCollections(namespace, shapeV12);
+    const rows = yield* sql `select * from ${sql(table)} order by admission_order`;
+    const model = modelFromColumns(columns);
+    const saveChildren = yield* makeRecordChildren(namespace, shapeV12);
+    for (const row of rows) {
+        const value = yield* textRecordValue(row, structured);
+        const input = yield* Schema.decodeUnknownEffect(model.insert)({ ...inputColumns(value, shapeV12), "work_id": row.work_id });
+        yield* sql `update ${sql(table)} set ${sql.update(yield* Schema.encodeEffect(model.insert)(input))} where work_id = ${row.work_id}`;
+        yield* saveChildren(String(row.work_id), value, false);
+    }
+    for (const name of structured) {
+        yield* sql `alter table ${sql(table)} drop column ${sql(`legacy_${name}`)}`;
+    }
+});
+//# sourceMappingURL=typedTables.js.map

package/dist/storage/typedTables.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/work-fleet",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Optional Board-backed execution, review and authorized delivery",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/work-fleet#readme",
   "bugs": {
@@ -45,20 +45,20 @@
   ],
   "dependencies": {
     "@effect/sql-pg": "4.0.4",
-    "@shivaedev/effect-contract": "0.5.0",
+    "@shivaedev/effect-contract": "0.5.1",
     "@shivaedev/effect-service": "0.3.0",
-    "@shivaedev/effect-sql": "0.3.0",
-    "@shivaedev/platform": "0.10.0",
-    "@shivaedev/work-board": "0.14.0",
+    "@shivaedev/effect-sql": "0.5.0",
+    "@shivaedev/platform": "0.14.0",
+    "@shivaedev/work-board": "0.14.1",
     "yaml": "2.9.1"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.4",
     "@effect/platform-node-shared": "4.0.4",
     "@effect/vitest": "4.0.4",
-    "@shivaedev/effect-test": "0.4.0",
-    "@shivaedev/effect-test-sql": "0.3.0",
-    "@shivaedev/quality": "0.21.0",
+    "@shivaedev/effect-test": "0.5.0",
+    "@shivaedev/effect-test-sql": "0.4.0",
+    "@shivaedev/quality": "0.22.0",
     "@types/node": "24.19.1",
     "@typescript/native": "npm:typescript@7.0.2",
     "effect": "4.0.4",

package/src/engine/abandonStalled.ts

@@ -0,0 +1,63 @@
+import { Effect, Result } from "effect";
+import type { EngineState } from "#engine/makeState.ts";
+import type { Attempt, FleetRecord } from "#model.ts";
+import type { SessionObservation } from "#session/schema.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export const abandonStalled = Effect.fn("Fleet.abandonStalled")(function* (state: EngineState, stored: Versioned<FleetRecord>) {
+	const latest = stored.value.attempts.at(-1);
+	if (!hasStalledAttempt(stored.value) || latest?.abandoned !== undefined) {
+		return stored;
+	}
+	const targets = stored.value.attempts.filter((attempt) => attempt === latest || ["submitting", "accepted", "running"].includes(attempt.status));
+	const at = state.policy.now();
+	let current = yield* state.save(stored, {
+		...stored.value,
+		attempts: stored.value.attempts.map((attempt) =>
+			targets.includes(attempt)
+				? {
+						...attempt,
+						abandoned: attempt.abandoned ?? { at, observation: lastObservation(attempt) },
+						output: undefined,
+						sessionUnusable: true,
+						status: "failed" as const,
+					}
+				: attempt,
+		),
+	});
+	for (const attempt of targets) {
+		const receipt = attempt.receipt;
+		if (receipt === undefined) {
+			continue;
+		}
+		const interrupted = yield* state.sessions.interrupt(receipt).pipe(Effect.timeout("5 seconds"), Effect.result);
+		const observed = yield* state.sessions.observe(receipt).pipe(Effect.timeout("5 seconds"), Effect.result);
+		const abandoned = {
+			at: attempt.abandoned?.at ?? at,
+			interruptError: Result.isFailure(interrupted) ? interrupted.failure.message : undefined,
+			observation: Result.isSuccess(observed) ? observed.success : (attempt.abandoned?.observation ?? lastObservation(attempt)),
+			observationError: Result.isFailure(observed) ? observed.failure.message : undefined,
+		};
+		current = yield* state.save(current, {
+			...current.value,
+			attempts: current.value.attempts.map((saved) => (saved.operationId === attempt.operationId ? { ...saved, abandoned } : saved)),
+		});
+	}
+	return current;
+});
+
+function hasStalledAttempt(record: FleetRecord): boolean {
+	const latest = record.attempts.at(-1);
+	return record.decision?.code === "session-stalled" || (latest?.sessionUnusable === true && (latest.stallRecovery?.count ?? 0) >= 2);
+}
+
+function lastObservation(attempt: Attempt): SessionObservation | undefined {
+	return attempt.receipt === undefined || attempt.status === "submitting"
+		? undefined
+		: {
+				execution: attempt.status,
+				output: attempt.output ?? "",
+				provisioning: "unknown",
+				receipt: attempt.receipt,
+			};
+}

package/src/engine/applyResolution.ts

@@ -69,6 +69,9 @@ function retryRework(state: EngineState) {
 			return undefined;
 		}
 		const latest = record.attempts.at(-1);
+		if (latest?.role === "reviewer" && latest.abandoned !== undefined) {
+			return undefined;
+		}
 		let changes = body.trim();
 		if (record.decision?.code === "pr-conflicting") {
 			changes = ["GitHub reports a conflict with main. Fetch and merge main, resolve the conflicts, and retain the requested changes.", changes]

package/src/engine/approveBrief.ts

@@ -1,10 +1,12 @@
 import { Effect } from "effect";
 import { workRevision } from "#board/workRevision.ts";
+import { abandonStalled } from "#engine/abandonStalled.ts";
 import { authorizeBrief, briefChanged } from "#engine/boardBrief.ts";
 import { closeDecisions } from "#engine/closeDecisions.ts";
 import { ensurePublication } from "#engine/ensurePublication.ts";
 import { launchPrompt } from "#engine/makeLaunch.ts";
 import type { EngineState } from "#engine/makeState.ts";
+import { briefSteerIntent, steerBrief } from "#engine/steerBrief.ts";
 import { executing, type FleetRecord } from "#model.ts";
 import type { BoardWork, DecisionResponse } from "#policy.ts";
 import type { Versioned } from "#storage/model.ts";
@@ -17,41 +19,41 @@ export function approveBrief(state: EngineState) {
 		responses?: readonly DecisionResponse[],
 	) {
 		yield* authorizeBrief(work);
-		const stored = yield* ensurePublication(state)(input);
+		const stored = yield* ensurePublication(state)(input).pipe(Effect.flatMap((current) => abandonStalled(state, current)));
 		const record = stored.value;
 		const published = record.decision?.published;
 		const approvedPrompt = prompt ?? revisedPrompt(record, work);
-		return yield* state
-			.save(stored, {
-				...record,
-				areas: work.areas,
-				attempts: record.attempts.map((attempt) =>
-					attempt.role === "reviewer" && attempt.reviewRevision === undefined
-						? { ...attempt, reviewRevision: workRevision(record.boardRevision, record.boardContext) }
-						: attempt,
-				),
-				blocker: undefined,
-				boardContext: work.context,
-				boardRevision: work.revision,
-				boardSourcePath: work.sourcePath,
-				checks: undefined,
-				decision: undefined,
-				decisionAcknowledged: undefined,
-				decisionPublished: undefined,
-				launchRetry: revisedRetry(record, approvedPrompt, state.policy.workerGuidance),
-				mergeAreasReleased: undefined,
-				mergeReadyAt: undefined,
-				mergeReadyHead: undefined,
-				prompt: approvedPrompt,
-				responses: responses ?? record.responses,
-				review: undefined,
-				stage: resumedStage(record),
-				supersededDecisions:
-					published === undefined
-						? record.supersededDecisions
-						: [...(record.supersededDecisions ?? []), { published, supersededAt: state.policy.now() }],
-			})
-			.pipe(Effect.flatMap(closeDecisions(state)));
+		const updated: FleetRecord = {
+			...record,
+			areas: work.areas,
+			attempts: record.attempts.map((attempt) =>
+				attempt.role === "reviewer" && attempt.reviewRevision === undefined
+					? { ...attempt, reviewRevision: workRevision(record.boardRevision, record.boardContext) }
+					: attempt,
+			),
+			blocker: undefined,
+			boardContext: work.context,
+			boardRevision: work.revision,
+			boardSourcePath: work.sourcePath,
+			checks: undefined,
+			decision: undefined,
+			decisionAcknowledged: undefined,
+			decisionPublished: undefined,
+			launchRetry: revisedRetry(record, approvedPrompt, state.policy.workerGuidance),
+			mergeAreasReleased: undefined,
+			mergeReadyAt: undefined,
+			mergeReadyHead: undefined,
+			prompt: approvedPrompt,
+			responses: responses ?? record.responses,
+			review: undefined,
+			stage: resumedStage(record),
+			supersededDecisions:
+				published === undefined
+					? record.supersededDecisions
+					: [...(record.supersededDecisions ?? []), { published, supersededAt: state.policy.now() }],
+		};
+		const approved = yield* state.save(stored, briefSteerIntent(record, updated, state.policy.now())).pipe(Effect.flatMap(closeDecisions(state)));
+		return yield* steerBrief(state, approved, record);
 	});
 }
 

package/src/engine/observedAttempt.ts

@@ -2,6 +2,9 @@ import type { Attempt } from "#model.ts";
 import type { SessionObservation } from "#session/schema.ts";
 
 export function observedAttempt(attempt: Attempt, observation: SessionObservation, now: number): Attempt {
+	if (attempt.abandoned !== undefined) {
+		return attempt;
+	}
 	const signature = observation.progress === undefined ? undefined : JSON.stringify(observation.progress);
 	const progress = signature === undefined || signature === attempt.progress?.signature ? attempt.progress : { at: now, signature };
 	return {

package/src/engine/prepareCommand.ts

@@ -43,12 +43,33 @@ export function prepareCommand(state: EngineState) {
 		if (unusedPreparation(existing.value)) {
 			return yield* save(existing, { ...current, history: existing.value.history });
 		}
+		if (refreshablePreparation(existing.value, work, input)) {
+			return yield* save(existing, {
+				...existing.value,
+				cwd: input.cwd,
+				launch: input.launch,
+				preparation: input.preparation,
+				prompt: input.prompt,
+			});
+		}
 		return yield* renewPreparation(state, existing, current, work);
 	});
 }
 function unusedPreparation(record: FleetRecord): boolean {
 	return record.stage === "prepared" && record.attempts.length === 0 && record.decision === undefined && (record.responses?.length ?? 0) === 0;
 }
+function refreshablePreparation(record: FleetRecord, work: BoardWork, input: PrepareWork): boolean {
+	return (
+		record.stage === "prepared"
+		&& record.decision === undefined
+		&& record.result === undefined
+		&& !executing(record)
+		&& !briefChanged(record, work)
+		&& record.cwd === input.cwd
+		&& record.preparation.ownedPaths.length === input.preparation.ownedPaths.length
+		&& record.preparation.ownedPaths.every((path, index) => path === input.preparation.ownedPaths[index])
+	);
+}
 const renewPreparation = Effect.fn("Fleet.renewPreparation")(function* (
 	state: EngineState,
 	input: Versioned<FleetRecord>,

package/src/engine/recoverStall.ts

@@ -30,11 +30,15 @@ export const recoverStall = Effect.fn("Fleet.recoverStall")(function* (
 	}
 	const count = recovery?.count ?? 0;
 	if (count >= 2) {
+		const exhausted = yield* state.save(stored, {
+			...stored.value,
+			attempts: stored.value.attempts.map((entry) => (entry.operationId === attempt.operationId ? { ...entry, sessionUnusable: true } : entry)),
+		});
 		return yield* state.decision(
-			stored,
+			exhausted,
 			"session-stalled",
 			"Provider turn stalled after automatic steer and interrupt recovery",
-			"Inspect the worker thread and retry or safely release",
+			"Retry in a fresh session or abandon the stalled turn and release ownership",
 		);
 	}
 	if (count === 0) {

package/src/engine/repository.ts

@@ -60,6 +60,7 @@ const FleetSessionJournal = defineService({
 				const original = stored.value.attempts.find((attempt) => attempt.operationId === operationId);
 				if (
 					original === undefined
+					|| original.abandoned !== undefined
 					|| (original.sessionId === undefined && original.status !== "submitting")
 					|| (original.role === "reviewer"
 						&& allAttempts(stored.value).some((attempt) => attempt.role !== "reviewer" && attempt.sessionId === sessionId))

package/src/engine/resolveExecution.ts

@@ -1,4 +1,5 @@
 import { Effect } from "effect";
+import { abandonStalled } from "#engine/abandonStalled.ts";
 import { authorizeResolution } from "#engine/authorizeResolution.ts";
 import type { EngineState } from "#engine/makeState.ts";
 import { releaseExecution } from "#engine/releaseExecution.ts";
@@ -14,7 +15,8 @@ export const resolveExecution = Effect.fn("Fleet.resolveExecution")(function* (
 	if (action === "retry") {
 		yield* authorizeResolution(state, stored.value, action);
 	}
-	const fenced = yield* retireUnacknowledged(state, stored);
+	const resolved = yield* abandonStalled(state, stored);
+	const fenced = yield* retireUnacknowledged(state, resolved);
 	const current = action === "release" && executing(fenced.value) ? yield* releaseExecution(state, fenced) : fenced;
 	if (action === "release") {
 		yield* authorizeResolution(state, current.value, action);

package/src/engine/sessionCleanup.ts

@@ -24,7 +24,9 @@ export function cleanupSessions({ sessions, load, save }: EngineState) {
 	return Effect.fn("Fleet.cleanupSessions")(function* (input: Versioned<FleetRecord>) {
 		let stored = input;
 		for (const id of pendingSessionCleanup(stored.value)) {
-			const result = yield* sessions.archive(id).pipe(Effect.result);
+			const abandoned = allAttempts(stored.value).some((attempt) => sessionId(attempt) === id && attempt.abandoned !== undefined);
+			const archive = sessions.archive(id);
+			const result = yield* (abandoned ? archive.pipe(Effect.timeout("5 seconds")) : archive).pipe(Effect.result);
 			if (result._tag === "Failure") {
 				yield* Effect.logWarning("Fleet session cleanup failed; reconciliation will retry", Cause.fail(result.failure)).pipe(
 					Effect.annotateLogs({ sessionId: id }),

package/src/engine/sessionStatus.ts

@@ -10,5 +10,10 @@ export function sessionStatus(session: (typeof FleetView.Type)["sessions"][numbe
 	return [
 		`session ${session.sessionId} turn ${session.turnId}`,
 		...times.flatMap(([label, time]) => (time === undefined ? [] : [`${label} ${new Date(time).toISOString()}`])),
+		...(session.briefSteers ?? []).map((steer) =>
+			steer.steeredAt === undefined
+				? `brief edit steer requested ${new Date(steer.requestedAt).toISOString()}; ${steer.error === undefined ? "delivery unconfirmed" : `failed: ${steer.error}`}`
+				: `brief edit steered ${new Date(steer.steeredAt).toISOString()}`,
+		),
 	].join("; ");
 }