@shivaedev/work-fleet 0.1.1 → 0.2.0

package/src/engine/steerBrief.ts

@@ -0,0 +1,54 @@
+import { Effect, Result } from "effect";
+import { workRevision } from "#board/workRevision.ts";
+import type { EngineState } from "#engine/makeState.ts";
+import type { FleetRecord } from "#model.ts";
+import { briefEditPrompt } from "#prompt/briefEdit.ts";
+import type { Versioned } from "#storage/model.ts";
+
+export function briefSteerIntent(previous: FleetRecord, record: FleetRecord, requestedAt: number): FleetRecord {
+	const revision = workRevision(record.boardRevision, record.boardContext);
+	const attempt = record.attempts.at(-1);
+	if (
+		revision === workRevision(previous.boardRevision, previous.boardContext)
+		|| record.stage !== "executing"
+		|| attempt?.receipt === undefined
+		|| attempt.role === "reviewer"
+		|| !["accepted", "running"].includes(attempt.status)
+		|| attempt.briefSteers?.some((entry) => entry.revision === revision)
+	) {
+		return record;
+	}
+	return {
+		...record,
+		attempts: record.attempts.map((entry) =>
+			entry.operationId === attempt.operationId ? { ...entry, briefSteers: [...(entry.briefSteers ?? []), { requestedAt, revision }] } : entry,
+		),
+	};
+}
+
+export const steerBrief = Effect.fn("Fleet.steerBrief")(function* (state: EngineState, stored: Versioned<FleetRecord>, previous: FleetRecord) {
+	const record = stored.value;
+	const revision = workRevision(record.boardRevision, record.boardContext);
+	const attempt = record.attempts.at(-1);
+	const intent = attempt?.briefSteers?.find((entry) => entry.revision === revision);
+	if (
+		attempt?.receipt === undefined
+		|| intent === undefined
+		|| previous.attempts.some((entry) => entry.operationId === attempt.operationId && entry.briefSteers?.some((saved) => saved.revision === revision))
+	) {
+		return stored;
+	}
+	const result = yield* state.sessions
+		.steer(attempt.receipt, briefEditPrompt(previous.boardContext, record.boardContext ?? record.prompt))
+		.pipe(Effect.result);
+	const evidence = Result.isFailure(result) ? { error: result.failure.message } : { steeredAt: state.policy.now() };
+	const current = yield* state.load(record.workId);
+	return yield* state.save(current, {
+		...current.value,
+		attempts: current.value.attempts.map((entry) =>
+			entry.operationId === attempt.operationId
+				? { ...entry, briefSteers: entry.briefSteers?.map((saved) => (saved.revision === revision ? { ...saved, ...evidence } : saved)) }
+				: entry,
+		),
+	});
+});

package/src/engine/views.ts

@@ -33,6 +33,7 @@ function sessionView(attempt: Attempt) {
 		: [
 				{
 					...attempt.receipt,
+					briefSteers: attempt.briefSteers,
 					interruptedAt: attempt.stallRecovery?.interruptedAt,
 					interruptRequestedAt: attempt.stallRecovery?.interruptRequestedAt,
 					lastProgressAt: attempt.progress?.at,

package/src/host/admission.ts

@@ -57,7 +57,8 @@ function unlaunched(record: FleetRecord) {
 }
 
 function stalePreparation(record: FleetRecord, work: BoardWork, main: MainSnapshot) {
-	return unlaunched(record) && (briefChanged(record, work) || record.preparation.baseRevision !== main.revision);
+	const changed = briefChanged(record, work);
+	return record.stage === "prepared" && (unlaunched(record) || !changed) && (changed || record.preparation.baseRevision !== main.revision);
 }
 
 export type Approval = "board" | "explicit";

package/src/host/readWaitStates.ts

@@ -1,16 +1,23 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import { Model } from "effect/schema";
 import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
 import { State } from "#host/waitOutcome.ts";
-import { recordColumns, recordJson, recordModel } from "#storage/model.ts";
+import { columnSchema, schemaShape, shapeColumns } from "#storage/recordShape.ts";
+import { recordValues } from "#storage/recordValue.ts";
 
 export interface ReadOptions {
 	readonly namespace: string;
 }
 
 export const readWaitStates = Effect.fn("FleetReader.readWaitStates")(function* (options: ReadOptions, ids?: readonly string[]) {
+	const shape = schemaShape(State);
+	class SnapshotRow extends Model.Class<SnapshotRow>("FleetSnapshot")({
+		...Object.fromEntries(Object.entries(shapeColumns(shape)).map(([name, kind]) => [name, columnSchema(kind)])),
+		"work_id": Schema.String,
+	}) {}
 	const read = Effect.gen(function* () {
-		const repository = yield* makeRepository(recordModel(), {
+		const repository = yield* makeRepository(SnapshotRow, {
 			idColumn: "work_id",
 			spanPrefix: "FleetReader",
 			tableName: `${options.namespace}_records`,
@@ -18,7 +25,6 @@ export const readWaitStates = Effect.fn("FleetReader.readWaitStates")(function*
 		const rows = yield* repository
 			.findMany({
 				orderBy: { direction: "asc", field: "work_id" },
-				select: ["work_id", "stage", "blocker", "attentionOwner", "checks", "decision", "outcome"],
 			})
 			.pipe(
 				Effect.catchTag("SqlError", (error) => {
@@ -26,14 +32,9 @@ export const readWaitStates = Effect.fn("FleetReader.readWaitStates")(function*
 					return typeof cause === "object" && cause !== null && "code" in cause && cause.code === "42P01" ? Effect.succeed([]) : Effect.fail(error);
 				}),
 			);
-		return yield* Effect.forEach(
-			rows.filter((row) => ids === undefined || ids.includes(row.work_id)),
-			(row) =>
-				recordJson(row, recordColumns()).pipe(
-					Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(State))),
-					Effect.map((state) => ({ ...state, outcome: state.outcome ?? {} })),
-				),
-		);
+		const selected = rows.filter((row) => ids === undefined || ids.includes(row.work_id));
+		const states = yield* Schema.decodeUnknownEffect(Schema.Array(State))(yield* recordValues(selected, shape, options.namespace));
+		return states.map((state) => ({ ...state, outcome: state.outcome ?? {} }));
 	});
 	return yield* read;
 });

package/src/host/recordPayloads.ts

@@ -1,7 +1,10 @@
 import { Effect } from "effect";
 import { SqlClient } from "effect/sql";
 import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
-import { recordColumns, recordJson, recordModel } from "#storage/model.ts";
+import { recordModel } from "#storage/model.ts";
+import { readRecords } from "#storage/readRecords.ts";
+import { recordShape } from "#storage/recordShape.ts";
+import { recordValues } from "#storage/recordValue.ts";
 
 export const recordPayloads = Effect.fn("FleetHost.recordPayloads")(function* (namespace: string, workId?: string) {
 	const sql = yield* SqlClient.SqlClient;
@@ -11,6 +14,11 @@ export const recordPayloads = Effect.fn("FleetHost.recordPayloads")(function* (n
 		return [];
 	}
 	const repository = yield* makeRepository(recordModel(), { idColumn: "work_id", spanPrefix: "FleetReader", tableName: table });
-	const rows = yield* repository.findMany({ orderBy: { direction: "asc", field: "work_id" }, where: { "work_id": workId } });
-	return yield* Effect.forEach(rows, (row) => recordJson(row, recordColumns()));
+	return yield* readRecords(
+		namespace,
+		Effect.gen(function* () {
+			const rows = yield* repository.findMany({ orderBy: { direction: "asc", field: "work_id" }, where: { "work_id": workId } });
+			return (yield* recordValues(rows, recordShape(), namespace)).map((value) => JSON.stringify(value));
+		}),
+	);
 });

package/src/model.ts

@@ -4,8 +4,26 @@ import { AttentionOwner } from "#attention.ts";
 import { BoardReport } from "#board/schema.ts";
 import { Checks, Decision, DecisionResponse, Delivery, Review, SupersededDecision, WorkResult } from "#policy.ts";
 import { Preparation } from "#preparation/schema.ts";
-import { LaunchSettings, SessionReceipt } from "#session/schema.ts";
+import { LaunchSettings, SessionObservation, SessionReceipt } from "#session/schema.ts";
 export const Attempt = Schema.Struct({
+	abandoned: Schema.optional(
+		Schema.Struct({
+			at: Schema.Number,
+			interruptError: Schema.optional(Schema.String),
+			observation: Schema.optional(SessionObservation),
+			observationError: Schema.optional(Schema.String),
+		}),
+	),
+	briefSteers: Schema.optional(
+		Schema.Array(
+			Schema.Struct({
+				error: Schema.optional(Schema.String),
+				requestedAt: Schema.Number,
+				revision: Schema.String,
+				steeredAt: Schema.optional(Schema.Number),
+			}),
+		),
+	),
 	checkFailures: Schema.optional(Schema.Array(Schema.String)),
 	missingSince: Schema.optional(Schema.Number),
 	observationRetries: Schema.optional(Schema.Number),
@@ -99,6 +117,7 @@ export const FleetView = Schema.Struct({
 	sessions: Schema.Array(
 		Schema.Struct({
 			...SessionReceipt.fields,
+			briefSteers: Attempt.fields.briefSteers,
 			interruptedAt: Schema.optional(Schema.Number),
 			interruptRequestedAt: Schema.optional(Schema.Number),
 			lastProgressAt: Schema.optional(Schema.Number),

package/src/packageInfo.ts

@@ -1,3 +1,3 @@
 export const NAME = "work-fleet";
 export const TITLE = "Work Fleet";
-export const VERSION = "0.1.1";
+export const VERSION = "0.2.0";

package/src/prompt/briefEdit.ts

@@ -0,0 +1,44 @@
+import { board as boardApi } from "@shivaedev/work-board/integration/board.ts";
+import { fleetDeliverable } from "#board/fleetField.ts";
+
+export function briefEditPrompt(previous: string | undefined, current: string): string {
+	const before = boardApi.metadataParse(previous ?? "");
+	const after = boardApi.metadataParse(current);
+	const criteria = new Map((before.fields.criteria ?? []).map(({ id, text }) => [id, text]));
+	const next = new Map((after.fields.criteria ?? []).map(({ id, text }) => [id, text]));
+	const changes = [...new Set([...criteria.keys(), ...next.keys()])].flatMap((id) =>
+		criteria.get(id) === next.get(id) ? [] : [`Criterion ${id}: ${criteria.get(id) ?? "(added)"} -> ${next.get(id) ?? "(removed)"}`],
+	);
+	if (before.body !== after.body) {
+		changes.push(...bodyChanges(before.body, after.body));
+	}
+	for (const field of ["kind", "relationships"] as const) {
+		if (JSON.stringify(before.fields[field]) !== JSON.stringify(after.fields[field])) {
+			changes.push(`The ${field} changed.`);
+		}
+	}
+	if (fleetDeliverable(before) !== fleetDeliverable(after)) {
+		changes.push("The deliverable changed.");
+	}
+	return [
+		"Fleet approved an edited brief. Apply this correction to your running work.",
+		"What changed:",
+		...changes,
+		"Full new brief:",
+		current,
+	].join("\n\n");
+}
+
+function bodyChanges(before: string, after: string): readonly string[] {
+	const removed = before.split("\n");
+	const added = after.split("\n");
+	while (removed.length > 0 && added.length > 0 && removed[0] === added[0]) {
+		removed.shift();
+		added.shift();
+	}
+	while (removed.length > 0 && added.length > 0 && removed.at(-1) === added.at(-1)) {
+		removed.pop();
+		added.pop();
+	}
+	return [`Previous title/body excerpt:\n${removed.join("\n") || "(empty)"}`, `New title/body excerpt:\n${added.join("\n") || "(empty)"}`];
+}

package/src/prompt/worker.ts

@@ -36,7 +36,8 @@ export function cloudStartup({ sharedEnvironment }: CloudStartup, access?: "read
 	return [
 		"Cloud startup:",
 		"- Your workspace may still be provisioning when this message arrives. If the cloud-environment runtime skill offers wait_for_environment, call it and wait calmly until the environment is ready; this usually takes about 90 seconds. Do not explore the snapshot or retry commands while waiting. Your instructions below stay valid.",
-		`- Source ${sharedEnvironment} at the start of EVERY independent shell command when it exists. The pinned Node, pnpm and Bun, the proxy, CA trust, caches and database settings come from it.`,
+		"- Default login shells activate the pinned Node, pnpm, Bun, gh and psql and every shared environment export through the profile hook, including the proxy, CA trust, caches and database settings.",
+		`- If \`node -v\` does not report the repository's \`.node-version\`, source ${sharedEnvironment} once in that command and say so in the final message.`,
 		...(access === "read-only"
 			? []
 			: [
@@ -47,13 +48,21 @@ export function cloudStartup({ sharedEnvironment }: CloudStartup, access?: "read
 
 export function workerPrompt(input: WorkerPrompt) {
 	if (input.deliverable === "report") {
-		return [`Work Board task: ${input.workId}`, "", cloudStartup(input), "", reportPrompt(input.task.trim())].join("\n");
+		return [
+			`Work Board task: ${input.workId}`,
+			"",
+			cloudStartup(input),
+			"- Before executing repository commands, run `./script/update` with escalation (require_escalated), since it installs dependencies.",
+			"",
+			reportPrompt(input.task.trim()),
+		].join("\n");
 	}
 	return [
 		`Work Board task: ${input.workId}`,
 		"",
 		cloudStartup(input),
 		`- Fetch origin/main and create ${input.branch} from that exact current revision, not from the environment snapshot. Use the supplied checkout and leave unrelated state alone.`,
+		"- Immediately after fetching origin/main and creating the branch, run `./script/update` with escalation (require_escalated), since it installs dependencies, before any other command or task work.",
 		"",
 		"Implement this approved Board task:",
 		"---",

package/src/storage/attemptV12.ts

@@ -0,0 +1,95 @@
+import type { Shape } from "#storage/recordShape.ts";
+
+export const attemptV12 = {
+	fields: {
+		abandoned: {
+			fields: {
+				at: "number",
+				interruptError: "string",
+				observation: {
+					fields: {
+						capacity: "string",
+						error: "string",
+						execution: "string",
+						output: "string",
+						progress: { array: { fields: { id: "string", status: "string" } } },
+						provisioning: "string",
+						receipt: { fields: { sessionId: "string", turnId: "string" } },
+						turnMissing: "boolean",
+					},
+				},
+				observationError: "string",
+			},
+		},
+		briefSteers: {
+			array: {
+				fields: {
+					error: "string",
+					requestedAt: "number",
+					revision: "string",
+					steeredAt: "number",
+				},
+			},
+		},
+		checkFailures: { array: "string" },
+		missingSince: "number",
+		observationRetries: "number",
+		operationId: "string",
+		output: "string",
+		progress: {
+			fields: {
+				at: "number",
+				signature: "string",
+			},
+		},
+		prompt: "string",
+		providerFailures: "number",
+		readRetry: {
+			fields: {
+				error: "string",
+				failures: "number",
+				retryAt: "number",
+			},
+		},
+		receipt: {
+			fields: {
+				sessionId: "string",
+				turnId: "string",
+			},
+		},
+		reviewHead: "string",
+		reviewRevision: "string",
+		role: "string",
+		sessionCleanupComplete: "boolean",
+		sessionId: "string",
+		sessionUnusable: "boolean",
+		settings: {
+			fields: {
+				effort: "string",
+				model: "string",
+				serviceTier: "string",
+			},
+		},
+		stallRecovery: {
+			fields: {
+				count: "number",
+				interruptedAt: "number",
+				interruptRequestedAt: "number",
+				lastActionAt: "number",
+				steeredAt: "number",
+			},
+		},
+		status: "string",
+		submissionTimedOut: "boolean",
+		submissionUncertain: "boolean",
+		submittedAt: "number",
+		terminalReceipts: {
+			array: {
+				fields: {
+					sessionId: "string",
+					turnId: "string",
+				},
+			},
+		},
+	},
+} as const satisfies Shape;

package/src/storage/createCollections.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { childTable, positions } from "#storage/recordChildren.ts";
+import { collections, type Shape, shapeColumns, sqlTypes } from "#storage/recordShape.ts";
+
+export const createCollections = Effect.fn("FleetStore.createCollections")(function* (namespace: string, shape: Shape) {
+	const sql = yield* SqlClient.SqlClient;
+	const table = `${namespace}_records`;
+	for (const collection of collections(shape)) {
+		const keys = positions(collection);
+		const fields = Object.entries(shapeColumns(collection.shape)).map(([name, kind]) => sql`${sql(name)} ${sql.literal(sqlTypes[kind])}`);
+		yield* sql`create table ${sql(childTable(namespace, collection.path))} (
+			work_id text not null references ${sql(table)} (work_id) on delete cascade,
+			${sql.csv(keys.map((key) => sql`${sql(key)} integer not null check (${sql(key)} >= 0)`))},
+			${sql.csv(fields)}, primary key (work_id, ${sql.csv(keys.map((key) => sql`${sql(key)}`))})
+		)`;
+		if (collection.path.at(-1) === "attempts") {
+			yield* sql`create index on ${sql(childTable(namespace, collection.path))} (${sql("operationId")})`;
+		}
+	}
+});

package/src/storage/cycleV12.ts

@@ -0,0 +1,125 @@
+import { preparationV12 } from "#storage/preparationV12.ts";
+import type { Shape } from "#storage/recordShape.ts";
+import { decisionV12, responsesV12, supersededDecisionsV12 } from "#storage/typedDecisionsV12.ts";
+
+export const cycleV12 = {
+	fields: {
+		admissionReady: "boolean",
+		areas: { array: "string" },
+		attentionOwner: "string",
+		blocker: "string",
+		boardContext: "string",
+		boardRevision: "string",
+		boardSourcePath: "string",
+		checks: {
+			fields: {
+				evidence: { array: "string" },
+				failedChecks: { array: "string" },
+				head: "string",
+				passed: "boolean",
+				pending: "boolean",
+				repairPrompt: "string",
+			},
+		},
+		completedAt: "number",
+		conflictRepairs: { array: "string" },
+		cwd: "string",
+		decision: decisionV12,
+		decisionAcknowledged: "boolean",
+		decisionPublished: "boolean",
+		deliverable: "string",
+		integrationRetry: {
+			fields: {
+				error: "string",
+				failures: "number",
+				retryAt: "number",
+			},
+		},
+		launch: {
+			fields: {
+				effort: "string",
+				model: "string",
+				serviceTier: "string",
+			},
+		},
+		launchRetry: {
+			fields: {
+				prompt: "string",
+				rejectedAt: "number",
+				rejections: "number",
+				retryAt: "number",
+			},
+		},
+		mergeAreasReleased: "boolean",
+		mergeReadyAt: "number",
+		mergeReadyHead: "string",
+		outcome: {
+			fields: {
+				evidence: { array: "string" },
+				head: "string",
+				revision: "string",
+				url: "string",
+			},
+		},
+		pendingAnswers: { array: "string" },
+		preparation: preparationV12,
+		prompt: "string",
+		releaseReason: "string",
+		report: {
+			fields: {
+				itemId: "string",
+				receipt: {
+					fields: {
+						sessionId: "string",
+						turnId: "string",
+					},
+				},
+				revision: "string",
+				sourcePath: "string",
+				workRevision: "string",
+			},
+		},
+		responses: responsesV12,
+		result: {
+			fields: {
+				evidence: { array: "string" },
+				head: "string",
+				kind: "string",
+				paths: { array: "string" },
+				pr: "string",
+				prNumber: "number",
+			},
+		},
+		resultObservations: {
+			array: {
+				fields: {
+					evidence: { array: "string" },
+					head: "string",
+					kind: "string",
+					paths: { array: "string" },
+					pr: "string",
+					prNumber: "number",
+				},
+			},
+		},
+		review: {
+			fields: {
+				evidence: { array: "string" },
+				findings: { array: "string" },
+				head: "string",
+				receipt: {
+					fields: {
+						sessionId: "string",
+						turnId: "string",
+					},
+				},
+				repairPrompt: "string",
+				verdict: "string",
+			},
+		},
+		stage: "string",
+		stageEnteredAt: "number",
+		supersededDecisions: supersededDecisionsV12,
+		updatedAt: "number",
+	},
+} as const satisfies Shape;

package/src/storage/fleetMigrations.ts

@@ -1,21 +1,13 @@
 import { Effect } from "effect";
 import { Migrator, SqlClient } from "effect/sql";
 import { backfillDecisionCodes } from "#storage/backfillDecisionCodes.ts";
-import { modelTableColumns, modelTables } from "#storage/modelTables.ts";
+import { modelTables } from "#storage/modelTables.ts";
 import { pruneEmptyCycles } from "#storage/pruneEmptyCycles.ts";
 import { recordTimeColumns } from "#storage/recordTimes.ts";
+import { typedTables } from "#storage/typedTables.ts";
 
 const releaseReasonColumn = { kind: "string", name: "releaseReason" } as const;
 
-// PostgreSQL text cannot distinguish scalar strings from serialized JSON.
-export const fleetMigrationColumns = {
-	...modelTableColumns,
-	[releaseReasonColumn.name]: releaseReasonColumn.kind,
-	...recordTimeColumns,
-	integrationRetry: "json",
-	pendingAnswers: "json",
-} as const;
-
 export const fleetMigrations = Effect.fn("FleetStore.fleetMigrations")(function* (namespace: string, legacyOnly = false) {
 	const sql = yield* SqlClient.SqlClient;
 	return yield* Migrator.fromRecord({
@@ -55,6 +47,7 @@ export const fleetMigrations = Effect.fn("FleetStore.fleetMigrations")(function*
 					"9_integration_retry": sql`alter table ${sql(`${namespace}_records`)} add column ${sql("integrationRetry")} text`,
 					"10_prune_empty_cycles": pruneEmptyCycles(namespace),
 					"11_pending_answers": sql`alter table ${sql(`${namespace}_records`)} add column ${sql("pendingAnswers")} text`,
+					"12_typed_tables": typedTables(namespace),
 				}),
 	});
 });

package/src/storage/legacyColumns.ts

@@ -0,0 +1,12 @@
+import { modelTableColumns } from "#storage/modelTables.ts";
+
+// PostgreSQL text cannot distinguish scalar strings from serialized JSON.
+export const legacyColumns = {
+	...modelTableColumns,
+	completedAt: "number",
+	integrationRetry: "json",
+	pendingAnswers: "json",
+	releaseReason: "string",
+	stageEnteredAt: "number",
+	updatedAt: "number",
+} as const;

package/src/storage/makeForeignReservations.ts

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql";
+import { makeRepository } from "@shivaedev/effect-sql/repository.ts";
+import { fleetRecords } from "#fleetRecords.ts";
+import { makeFleetTransaction } from "#storage/makeFleetTransaction.ts";
+import { ForeignReservationRow } from "#storage/model.ts";
+
+export const makeForeignReservations = Effect.fn("FleetStore.makeForeignReservations")(function* (namespace: string) {
+	const sql = yield* SqlClient.SqlClient;
+	const commit = yield* makeFleetTransaction;
+	const reservations = yield* makeRepository(ForeignReservationRow, {
+		idColumn: "owner",
+		spanPrefix: "FleetForeign",
+		tableName: `${namespace}_foreign_reservations`,
+	});
+	const lock = sql`select pg_advisory_xact_lock(hashtextextended(${`work_fleet_admission:${namespace}`}, 0))`;
+	return {
+		foreignReservations: () => reservations.findMany({ orderBy: { direction: "asc", field: "owner" } }),
+		releaseForeign: (owner: string) =>
+			commit(
+				[fleetRecords.list],
+				Effect.gen(function* () {
+					yield* lock;
+					yield* reservations.delete(owner);
+				}),
+			),
+		reserveForeign: (owner: string, occupancy: { readonly executing: boolean; readonly backlog: boolean } = { backlog: true, executing: true }) =>
+			commit(
+				[fleetRecords.list],
+				Effect.gen(function* () {
+					yield* lock;
+					const existing = yield* reservations.findMany({ where: { owner } });
+					if (existing.length === 0) {
+						yield* reservations.insertVoid({ owner, ...occupancy });
+					} else {
+						yield* reservations.updateVoid({ owner, ...occupancy });
+					}
+				}),
+			),
+	};
+});