octaflow 0.37.0 → 0.38.0

package/dist/document/index.js

@@ -189,7 +189,7 @@ function checkSchemaSubset(schema, path) {
 		return issues;
 	}
 	for (const keyword of Object.keys(s)) {
-		if (keyword === "type" || ANNOTATIONS.has(keyword) || BY_TYPE[type].has(keyword)) continue;
+		if (keyword === "type" || ANNOTATIONS.has(keyword) || keyword.startsWith("x-") || BY_TYPE[type].has(keyword)) continue;
 		at(`${path}.${keyword}`, `"${keyword}" is not part of the schema subset for type ${type}`);
 	}
 	if (type === "string" && s.format !== void 0 && (typeof s.format !== "string" || !FORMATS.has(s.format))) at(`${path}.format`, `format must be one of ${[...FORMATS].join(", ")}`);
@@ -1586,8 +1586,27 @@ const humanApproveKind = defineKind({
 		subject: z.unknown(),
 		instructions: z.string().optional(),
 		/** What the person may decide; `approve` among them. Default approve and reject — add `revise`, or `expired` for a timeout's answer. */
-		decisions: z.array(z.string().min(1)).min(2).refine((d) => d.includes("approve"), "the decisions include \"approve\"").optional()
+		decisions: z.array(z.string().min(1)).min(2).refine((d) => d.includes("approve"), "the decisions include \"approve\"").optional(),
+		/**
+		* Approvals of the same run this one must come from someone else than — four eyes. The compiler holds
+		* each to a step upstream that says who answered it (`output.by`, which an approval does); the host
+		* holds an answer to it, since only it knows who answers.
+		*/
+		distinctFrom: z.array(z.string().min(1)).optional()
 	},
+	check: ({ params, checkExpr }) => {
+		const others = params.distinctFrom;
+		if (others === void 0) return [];
+		if (!Array.isArray(others) || !others.every((k) => typeof k === "string")) return [{
+			path: "distinctFrom",
+			message: "names the approval steps by key"
+		}];
+		return others.flatMap((k, i) => checkExpr(`steps.${k}.output.by`).errors.length ? [{
+			path: `distinctFrom.${i}`,
+			message: `"${k}" is no approval upstream of this one`
+		}] : []);
+	},
+	reads: (params) => Array.isArray(params.distinctFrom) ? params.distinctFrom.map((k) => `steps.${k}.output.by`) : [],
 	actor: "person",
 	approval: true,
 	wait: true,

package/dist/postgres/index.d.ts

@@ -44,16 +44,22 @@ export interface SqlExecutor {
  */
 export declare function poolExecutor(pool: Pool): SqlExecutor;
 /**
- * The slice of a postgres.js `sql` instance {@link postgresJsExecutor} uses —
- * structural, so the driver is never imported. `sql.unsafe` resolves to the row
- * list with the affected-row `count` on it; `sql.begin` runs its callback on one
- * reserved connection inside `BEGIN`/`COMMIT` and hands it a `sql` of the same shape.
+ * The slice of a postgres.js transaction `sql` {@link postgresJsExecutor} uses: `unsafe` alone. postgres.js hands
+ * `begin`'s callback a `TransactionSql`, which has no `begin` of its own, and the executor never nests.
  */
-export interface PostgresJsSqlLike {
+export interface PostgresJsTransactionLike {
   unsafe(query: string, params?: unknown[]): PromiseLike<unknown[] & {
     count?: number | null;
   }>;
-  begin<T>(fn: (tx: PostgresJsSqlLike) => Promise<T>): PromiseLike<T>;
+}
+/**
+ * The slice of a postgres.js `sql` instance {@link postgresJsExecutor} uses —
+ * structural, so the driver is never imported. `sql.unsafe` resolves to the row
+ * list with the affected-row `count` on it; `sql.begin` runs its callback on one
+ * reserved connection inside `BEGIN`/`COMMIT` and hands it a transaction `sql`.
+ */
+export interface PostgresJsSqlLike extends PostgresJsTransactionLike {
+  begin<T>(fn: (tx: PostgresJsTransactionLike) => Promise<T>): PromiseLike<T>;
 }
 /**
  * Build a {@link SqlExecutor} over a postgres.js `sql` instance: top-level

package/dist/postgres/index.js

@@ -150,19 +150,21 @@ const isoDates = (params) => params.map((p) => p instanceof Date ? p.toISOString
 * {@link poolExecutor}.
 */
 function postgresJsExecutor(sql) {
-	const over = (conn, inTransaction) => ({
-		async query(text, params) {
-			const rows = await conn.unsafe(text, isoDates(params ?? []));
-			return {
-				rows: Array.from(rows),
-				rowCount: rows.count ?? rows.length
-			};
-		},
-		transaction(fn) {
-			return inTransaction ? fn(over(conn, true)) : Promise.resolve(conn.begin((tx) => fn(over(tx, true))));
-		}
+	const query = (conn) => async function(text, params) {
+		const rows = await conn.unsafe(text, isoDates(params ?? []));
+		return {
+			rows: Array.from(rows),
+			rowCount: rows.count ?? rows.length
+		};
+	};
+	const inTransaction = (tx) => ({
+		query: query(tx),
+		transaction: (fn) => fn(inTransaction(tx))
 	});
-	return over(sql, false);
+	return {
+		query: query(sql),
+		transaction: (fn) => Promise.resolve(sql.begin((tx) => fn(inTransaction(tx))))
+	};
 }
 /**
 * Build a {@link SqlExecutor} over a PGlite instance — the embedded Postgres a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octaflow",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "Durable DAG workflow engine: Zod-typed steps over Postgres + pg-boss. The model layer is @octabits-io/models.",
   "license": "MIT",
   "type": "module",
@@ -66,7 +66,6 @@
     "drizzle-orm": ">=0.36.0 <1",
     "pg": "^8.0.0",
     "pg-boss": "^12.21.0",
-    "typescript": "^5 || ^6 || ^7",
     "zod": "^4.6.0"
   },
   "peerDependenciesMeta": {

package/skills/add-a-case-loop/SKILL.md

@@ -19,10 +19,10 @@ the case.
 … body … ─► result ─► decide (manager) ─► next ─► move N+1 | case closed
 ```
 
-Shown end to end in `apps/demo-task-loop/src/moves.ts` (Postgres, pg-boss, a customer agent
-that answers by resuming the move that waits for it), with whole cases on scripted models in
-`apps/demo-task-loop/src/moves.test.ts`. The loop's own tests are
-`packages/octaflow/src/ai/case-loop.test.ts`.
+Shown end to end, written as a case document, in the office: `apps/demo-office/src/features/office/case/`
+(the document, the office's kinds, a customer agent that answers by resuming the move that waits
+for it), with whole cases on the scripted model in `apps/demo-office/src/overdue-invoice.test.ts`.
+The loop's own tests are `packages/octaflow/src/ai/case-loop.test.ts`.
 
 **Which pattern?**
 
@@ -110,7 +110,7 @@ means the move stopped waiting — keep the answer where the next `wait` move fi
 ## Prove it works
 
 A test on the in-memory engine with one scripted model whose lines are routed by the system
-prompt — `apps/demo-task-loop/src/moves.test.ts` is the template — that asserts:
+prompt — `apps/demo-office/src/overdue-invoice.test.ts` is the template — that asserts:
 
 - a whole case: the moves in order, the outcome the host recorded;
 - a refused choice is in `decide`'s `refusals` with its reason, and the next choice is taken;