substrate-ai 0.7.0 → 0.8.0

package/dist/{health-Dnx-FGva.js → health-C-VRJruD.js}

@@ -158,6 +158,17 @@ var DoltDatabaseAdapter = class {
 //#region src/persistence/memory-adapter.ts
 var InMemoryDatabaseAdapter = class {
 	_tables = new Map();
+	_indexes = [];
+	/** Maps table name → auto-increment column name */
+	_autoIncrementCols = new Map();
+	/** Maps table name → last assigned auto-increment value */
+	_autoIncrementCounters = new Map();
+	/** Maps "tableName.colName" → default value expression ('CURRENT_TIMESTAMP' → ISO string, else literal) */
+	_columnDefaults = new Map();
+	/** Maps table name → array of primary key column names */
+	_primaryKeys = new Map();
+	/** Maps table name → ordered list of column names (from CREATE TABLE) */
+	_tableColumns = new Map();
 	async query(sql, params) {
 		const rows = this._execute(sql.trim(), params);
 		return rows;
@@ -165,14 +176,23 @@ var InMemoryDatabaseAdapter = class {
 	async exec(sql) {
 		this._execute(sql.trim(), void 0);
 	}
+	querySync(sql, params) {
+		const rows = this._execute(sql.trim(), params);
+		return rows;
+	}
+	execSync(sql) {
+		this._execute(sql.trim(), void 0);
+	}
 	async transaction(fn) {
 		const snapshot = new Map();
 		for (const [name, rows] of this._tables) snapshot.set(name, rows.map((r) => ({ ...r })));
+		const counterSnapshot = new Map(this._autoIncrementCounters);
 		try {
 			const result = await fn(this);
 			return result;
 		} catch (err) {
 			this._tables = snapshot;
+			this._autoIncrementCounters = counterSnapshot;
 			throw err;
 		}
 	}
@@ -191,11 +211,14 @@ var InMemoryDatabaseAdapter = class {
 		const upper = resolved.trimStart().toUpperCase();
 		if (/^CREATE\s+TABLE/i.test(upper)) return this._createTable(resolved);
 		if (/^DROP\s+TABLE/i.test(upper)) return this._dropTable(resolved);
+		if (/^CREATE\s+(?:UNIQUE\s+)?INDEX/i.test(upper)) return this._createIndex(resolved);
+		if (/^DROP\s+INDEX/i.test(upper)) return this._dropIndex(resolved);
 		if (/^CREATE\s+(?:OR\s+REPLACE\s+)?VIEW/i.test(upper)) return [];
 		if (/^INSERT\s+(?:IGNORE\s+)?INTO/i.test(upper)) return this._insert(resolved, /^INSERT\s+IGNORE\s+INTO/i.test(upper));
 		if (/^SELECT/i.test(upper)) return this._select(resolved);
 		if (/^UPDATE/i.test(upper)) return this._update(resolved);
 		if (/^DELETE\s+FROM/i.test(upper)) return this._delete(resolved);
+		if (/^PRAGMA\s+table_info\s*\(/i.test(upper)) return this._pragmaTableInfo(resolved);
 		return [];
 	}
 	/**
@@ -217,6 +240,50 @@ var InMemoryDatabaseAdapter = class {
 		if (m) {
 			const name = m[1];
 			if (!this._tables.has(name)) this._tables.set(name, []);
+			const colDefsM = /\((.+)\)\s*$/is.exec(sql);
+			if (colDefsM) {
+				const colDefs = colDefsM[1];
+				const aiMatch = /^\s*(\w+)\s+\w+.*?(?:AUTO_INCREMENT|AUTOINCREMENT)/im.exec(colDefs);
+				if (aiMatch) {
+					this._autoIncrementCols.set(name, aiMatch[1]);
+					if (!this._autoIncrementCounters.has(name)) this._autoIncrementCounters.set(name, 0);
+				}
+				const colLines = this._splitTopLevelCommas(colDefs);
+				const pkCols = [];
+				for (const colLine of colLines) {
+					const trimmedLine = colLine.trim();
+					const tablePkM = /^PRIMARY\s+KEY\s*\(([^)]+)\)/i.exec(trimmedLine);
+					if (tablePkM) {
+						const cols = tablePkM[1].split(",").map((c) => c.trim().replace(/^[`"](.+)[`"]$/, "$1"));
+						pkCols.push(...cols);
+						continue;
+					}
+					const defaultM = /^\s*(\w+)\s+\S+.*?\bDEFAULT\s+(.+?)(?:\s*,?\s*$)/i.exec(trimmedLine);
+					if (defaultM) {
+						const colName = defaultM[1];
+						const defaultVal = defaultM[2].trim();
+						this._columnDefaults.set(`${name}.${colName}`, defaultVal);
+					}
+					const colPkM = /^(\w+)\s+\w+.*?\bPRIMARY\s+KEY\b/i.exec(trimmedLine);
+					if (colPkM && !/^PRIMARY\s+KEY\b/i.test(trimmedLine)) pkCols.push(colPkM[1]);
+				}
+				if (pkCols.length > 0 && !this._primaryKeys.has(name)) this._primaryKeys.set(name, pkCols);
+				if (!this._tableColumns.has(name)) {
+					const colNames = [];
+					for (const colLine of colLines) {
+						const trimmedLine = colLine.trim();
+						if (/^(?:PRIMARY\s+KEY|UNIQUE|FOREIGN\s+KEY|CHECK)\s*[\s(]/i.test(trimmedLine)) continue;
+						const quotedM = /^[`"](\w+)[`"]\s+\S/i.exec(trimmedLine);
+						if (quotedM) {
+							colNames.push(quotedM[1]);
+							continue;
+						}
+						const bareM = /^(\w+)\s+\S/i.exec(trimmedLine);
+						if (bareM) colNames.push(bareM[1]);
+					}
+					if (colNames.length > 0) this._tableColumns.set(name, colNames);
+				}
+			}
 		}
 		return [];
 	}
@@ -225,16 +292,101 @@ var InMemoryDatabaseAdapter = class {
 		if (m) this._tables.delete(m[1]);
 		return [];
 	}
+	_createIndex(sql) {
+		const m = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s+ON\s+(\w+)/i.exec(sql);
+		if (m) {
+			const name = m[1];
+			const tbl_name = m[2];
+			if (!this._indexes.some((idx) => idx.name === name)) this._indexes.push({
+				name,
+				tbl_name,
+				type: "index"
+			});
+		}
+		return [];
+	}
+	_dropIndex(sql) {
+		const m = /DROP\s+INDEX\s+(?:IF\s+EXISTS\s+)?(\w+)/i.exec(sql);
+		if (m) {
+			const name = m[1];
+			this._indexes = this._indexes.filter((idx) => idx.name !== name);
+		}
+		return [];
+	}
+	/**
+	* Emulate PRAGMA table_info(tableName) — returns one row per column with
+	* {cid, name, type, notnull, dflt_value, pk} shape.
+	* Column names are derived from the CREATE TABLE definition order.
+	* This is sufficient for schema compatibility checks.
+	*/
+	_pragmaTableInfo(sql) {
+		const m = /PRAGMA\s+table_info\s*\(\s*[`'"]?(\w+)[`'"]?\s*\)/i.exec(sql);
+		if (!m) return [];
+		const tableName = m[1];
+		const colNames = this._tableColumns.get(tableName);
+		if (!colNames || colNames.length === 0) return [];
+		const pkCols = this._primaryKeys.get(tableName) ?? [];
+		return colNames.map((name, cid) => ({
+			cid,
+			name,
+			type: "TEXT",
+			notnull: 0,
+			dflt_value: null,
+			pk: pkCols.includes(name) ? 1 : 0
+		}));
+	}
+	_selectFromSqliteMaster(sql) {
+		const masterRows = [];
+		for (const name of this._tables.keys()) masterRows.push({
+			type: "table",
+			name,
+			tbl_name: name,
+			rootpage: 0,
+			sql: null
+		});
+		for (const idx of this._indexes) masterRows.push({
+			type: "index",
+			name: idx.name,
+			tbl_name: idx.tbl_name,
+			rootpage: 0,
+			sql: null
+		});
+		const whereM = /WHERE\s+(.+?)(?:\s+ORDER\s+BY|\s+LIMIT|\s*$)/is.exec(sql);
+		let rows = masterRows;
+		if (whereM) rows = rows.filter((row) => this._matchWhere(whereM[1].trim(), row));
+		const colsM = /SELECT\s+(.+?)\s+FROM\s+sqlite_master/is.exec(sql);
+		if (!colsM) return rows;
+		const colsStr = colsM[1].trim();
+		if (colsStr === "*") return rows;
+		return rows.map((row) => this._projectCols(colsStr, row));
+	}
 	_insert(sql, _ignoreConflicts = false) {
 		const m = /INSERT\s+(?:IGNORE\s+)?INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\((.+)\)\s*$/is.exec(sql);
 		if (!m) return [];
 		const tableName = m[1];
-		const cols = m[2].split(",").map((c) => c.trim());
+		const cols = m[2].split(",").map((c) => c.trim().replace(/^[`"](.+)[`"]$/, "$1"));
 		const valStr = m[3];
 		const vals = this._parseValueList(valStr);
 		const row = {};
 		for (let i = 0; i < cols.length; i++) row[cols[i]] = vals[i] ?? null;
+		const aiCol = this._autoIncrementCols.get(tableName);
+		if (aiCol && !(aiCol in row)) {
+			const next = (this._autoIncrementCounters.get(tableName) ?? 0) + 1;
+			this._autoIncrementCounters.set(tableName, next);
+			row[aiCol] = next;
+		}
+		for (const [key, defaultExpr] of this._columnDefaults) {
+			const [tbl, col] = key.split(".");
+			if (tbl === tableName && !(col in row)) if (/^CURRENT_TIMESTAMP$/i.test(defaultExpr)) row[col] = new Date().toISOString();
+			else row[col] = this._evalLiteral(defaultExpr);
+		}
 		if (!this._tables.has(tableName)) this._tables.set(tableName, []);
+		const pkCols = this._primaryKeys.get(tableName);
+		if (pkCols && pkCols.length > 0 && !_ignoreConflicts) {
+			const table = this._tables.get(tableName);
+			const isDuplicate = table.some((existingRow) => pkCols.every((col) => existingRow[col] !== void 0 && String(existingRow[col]) === String(row[col])));
+			if (isDuplicate) throw new Error(`UNIQUE constraint failed: ${tableName} (${pkCols.join(", ")})`);
+		}
 		this._tables.get(tableName).push(row);
 		return [];
 	}
@@ -244,7 +396,20 @@ var InMemoryDatabaseAdapter = class {
 			if (!m$1) return [];
 			return [this._evalSelectExprs(m$1[1].trim())];
 		}
-		const stripped = sql.replace(/\s+ORDER\s+BY\s+.+?(?=\s+LIMIT\s|\s*$)/is, "").replace(/\s+LIMIT\s+\d+\s*$/is, "");
+		if (/FROM\s+sqlite_master/i.test(sql)) return this._selectFromSqliteMaster(sql);
+		let limitValue;
+		const limitMatch = /\s+LIMIT\s+(\d+)\s*$/is.exec(sql);
+		if (limitMatch) limitValue = parseInt(limitMatch[1], 10);
+		let orderByExprs;
+		const orderByMatch = /\s+ORDER\s+BY\s+(.+?)(?:\s+LIMIT\s+\d+\s*)?$/is.exec(sql);
+		if (orderByMatch) orderByExprs = this._parseOrderBy(orderByMatch[1].trim());
+		let stripped = sql.replace(/\s+ORDER\s+BY\s+.+?(?=\s+LIMIT\s|\s*$)/is, "").replace(/\s+LIMIT\s+\d+\s*$/is, "");
+		let groupByCols = null;
+		const groupByMatch = /\s+GROUP\s+BY\s+(.+?)(?:\s+HAVING\s+.+?)?$/is.exec(stripped);
+		if (groupByMatch) {
+			groupByCols = groupByMatch[1].split(",").map((c) => c.trim());
+			stripped = stripped.replace(/\s+GROUP\s+BY\s+.+$/is, "");
+		}
 		const m = /SELECT\s+(.+?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/is.exec(stripped);
 		if (!m) return [];
 		const colsStr = m[1].trim();
@@ -253,10 +418,201 @@ var InMemoryDatabaseAdapter = class {
 		const table = this._tables.get(tableName) ?? [];
 		let rows = table.map((r) => ({ ...r }));
 		if (whereStr) rows = rows.filter((row) => this._matchWhere(whereStr.trim(), row));
+		if (groupByCols !== null) {
+			const grouped = this._applyGroupBy(colsStr, rows, groupByCols);
+			const sorted = orderByExprs ? this._applyOrderBy(grouped, orderByExprs) : grouped;
+			return limitValue !== void 0 ? sorted.slice(0, limitValue) : sorted;
+		}
+		if (orderByExprs) rows = this._applyOrderBy(rows, orderByExprs);
+		if (limitValue !== void 0) rows = rows.slice(0, limitValue);
 		if (colsStr === "*") return rows;
 		if (/\b(?:SUM|COALESCE|COUNT|AVG|MIN|MAX)\s*\(/i.test(colsStr)) return [this._evalAggregate(colsStr, rows)];
 		return rows.map((row) => this._projectCols(colsStr, row));
 	}
+	/**
+	* Apply GROUP BY: bucket rows by the group-by columns, then evaluate
+	* aggregate expressions for each bucket. Plain column references in the
+	* SELECT list that are also GROUP BY columns return the group value from
+	* the first row in the bucket (all rows in a group share the same value).
+	*/
+	_applyGroupBy(colsStr, rows, groupByCols) {
+		const groups = new Map();
+		for (const row of rows) {
+			const key = groupByCols.map((col) => String(row[col] ?? "")).join("\0");
+			if (!groups.has(key)) groups.set(key, []);
+			groups.get(key).push(row);
+		}
+		const result = [];
+		for (const [, groupRows] of groups) result.push(this._evalAggregateGroup(colsStr, groupRows));
+		return result;
+	}
+	/**
+	* Parse ORDER BY expression list into sort keys.
+	* Handles: simple columns, COALESCE(col, default) DESC, CASE...END expressions.
+	*/
+	_parseOrderBy(orderByStr) {
+		const parts = this._splitTopLevelCommas(orderByStr);
+		return parts.map((part) => {
+			const trimmed = part.trim();
+			const dirMatch = /^(.*?)\s+(ASC|DESC)\s*$/i.exec(trimmed);
+			if (dirMatch) return {
+				expr: dirMatch[1].trim(),
+				dir: dirMatch[2].toUpperCase()
+			};
+			return {
+				expr: trimmed,
+				dir: "ASC"
+			};
+		});
+	}
+	/**
+	* Sort rows according to ORDER BY expression list.
+	*/
+	_applyOrderBy(rows, orderBy) {
+		return [...rows].sort((a, b) => {
+			for (const { expr, dir } of orderBy) {
+				const aVal = this._evalOrderByExpr(expr, a);
+				const bVal = this._evalOrderByExpr(expr, b);
+				const cmp = this._compareValues(aVal, bVal);
+				if (cmp !== 0) return dir === "DESC" ? -cmp : cmp;
+			}
+			return 0;
+		});
+	}
+	/**
+	* Evaluate an ORDER BY expression for a single row.
+	*/
+	_evalOrderByExpr(expr, row) {
+		const trimmed = expr.trim();
+		const simpleCaseM = /^CASE\s+(\w+)\s+(.+?)\s+END$/is.exec(trimmed);
+		if (simpleCaseM) {
+			const col = simpleCaseM[1];
+			const colVal = String(row[col] ?? "");
+			const body = simpleCaseM[2].trim();
+			const whenMatches = [...body.matchAll(/WHEN\s+'([^']*)'\s+THEN\s+(\S+)/gi)];
+			for (const wm of whenMatches) if (colVal === wm[1]) return this._evalLiteral(wm[2]);
+			const elseM = /ELSE\s+(\S+)\s*$/i.exec(body);
+			if (elseM) return this._evalLiteral(elseM[1]);
+			return null;
+		}
+		return this._evalRowExpr(trimmed, row);
+	}
+	/**
+	* Compare two values for sorting (handles null, numbers, strings).
+	* Returns negative if a < b, 0 if equal, positive if a > b.
+	*/
+	_compareValues(a, b) {
+		if (a === null || a === void 0) return b === null || b === void 0 ? 0 : 1;
+		if (b === null || b === void 0) return -1;
+		if (typeof a === "number" && typeof b === "number") return a - b;
+		return String(a).localeCompare(String(b));
+	}
+	/**
+	* Evaluate SELECT expressions against a single GROUP BY bucket.
+	* Handles both aggregate expressions (SUM, COUNT, COALESCE) and plain
+	* column references (for GROUP BY projected columns).
+	*/
+	_evalAggregateGroup(colsStr, rows) {
+		const result = {};
+		const cols = this._splitTopLevelCommas(colsStr);
+		for (const col of cols) {
+			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(col);
+			const expr = aliasM ? aliasM[1].trim() : col.trim();
+			const alias = aliasM ? aliasM[2] : col.trim();
+			result[alias] = this._evalAggregateExprGrouped(expr, rows);
+		}
+		return result;
+	}
+	/**
+	* Evaluate a single aggregate expression against a GROUP BY bucket.
+	* Extends _evalAggregateExpr with:
+	*   - SUM(expr)       where expr may be CASE WHEN ... END
+	*   - Plain column references (returns first-row value, for GROUP BY cols)
+	*/
+	_evalAggregateExprGrouped(expr, rows) {
+		const trimmed = expr.trim();
+		const coalesceM = /^COALESCE\((.+)\)$/i.exec(trimmed);
+		if (coalesceM) {
+			const args = this._splitTopLevelCommas(coalesceM[1]);
+			for (const arg of args) {
+				const val = this._evalAggregateExprGrouped(arg.trim(), rows);
+				if (val !== null && val !== void 0) return val;
+			}
+			return null;
+		}
+		const sumM = /^SUM\((.+)\)$/i.exec(trimmed);
+		if (sumM) {
+			if (rows.length === 0) return null;
+			let total = 0;
+			for (const row of rows) total += Number(this._evalRowExpr(sumM[1].trim(), row) ?? 0);
+			return total;
+		}
+		if (/^COUNT\(\*\)$/i.test(trimmed)) return rows.length;
+		const countColM = /^COUNT\((\w+)\)$/i.exec(trimmed);
+		if (countColM) {
+			const col = countColM[1];
+			return rows.filter((r) => r[col] !== null && r[col] !== void 0).length;
+		}
+		const maxColM = /^MAX\((\w+)\)$/i.exec(trimmed);
+		if (maxColM) {
+			const col = maxColM[1];
+			const values = rows.map((r) => r[col]).filter((v) => v !== null && v !== void 0);
+			if (values.length === 0) return null;
+			return values.reduce((a, b) => String(a) >= String(b) ? a : b);
+		}
+		const minColM = /^MIN\((\w+)\)$/i.exec(trimmed);
+		if (minColM) {
+			const col = minColM[1];
+			const values = rows.map((r) => r[col]).filter((v) => v !== null && v !== void 0);
+			if (values.length === 0) return null;
+			return values.reduce((a, b) => String(a) <= String(b) ? a : b);
+		}
+		if (/^\w+$/.test(trimmed) && rows.length > 0 && trimmed in rows[0]) return rows[0][trimmed];
+		return this._evalLiteral(trimmed);
+	}
+	/**
+	* Evaluate an expression for a single row.
+	* Supports CASE WHEN conditions, COALESCE, column references, and literals.
+	* Used by _evalAggregateExprGrouped to evaluate the argument of SUM().
+	*/
+	_evalRowExpr(expr, row) {
+		const trimmed = expr.trim();
+		const coalesceM = /^COALESCE\((.+)\)$/i.exec(trimmed);
+		if (coalesceM) {
+			const args = this._splitTopLevelCommas(coalesceM[1]);
+			for (const arg of args) {
+				const val = this._evalRowExpr(arg.trim(), row);
+				if (val !== null && val !== void 0) return val;
+			}
+			return null;
+		}
+		const caseM = /^CASE\s+WHEN\s+(.+?)\s+THEN\s+(.+?)\s+ELSE\s+(.+?)\s+END$/is.exec(trimmed);
+		if (caseM) {
+			const matches = this._evalRowCondition(caseM[1].trim(), row);
+			return this._evalRowExpr(matches ? caseM[2].trim() : caseM[3].trim(), row);
+		}
+		if (/^\w+$/.test(trimmed) && /^[a-zA-Z_]/.test(trimmed)) {
+			if (trimmed in row) return row[trimmed];
+			return null;
+		}
+		return this._evalLiteral(trimmed);
+	}
+	/**
+	* Evaluate a simple condition (col = 'str', col = num) for a single row.
+	* Returns true if the condition holds.
+	*/
+	_evalRowCondition(condition, row) {
+		const trimmed = condition.trim();
+		const strM = /^(\w+)\s*=\s*'(.*)'$/is.exec(trimmed);
+		if (strM) {
+			const colVal = String(row[strM[1]] ?? "");
+			const literal = strM[2].replace(/''/g, "'");
+			return colVal === literal;
+		}
+		const numM = /^(\w+)\s*=\s*(-?\d+(?:\.\d+)?)$/.exec(trimmed);
+		if (numM) return Number(row[numM[1]]) === parseFloat(numM[2]);
+		return false;
+	}
 	_update(sql) {
 		const m = /UPDATE\s+(\w+)\s+SET\s+(.+?)(?:\s+WHERE\s+(.+))?$/is.exec(sql);
 		if (!m) return [];
@@ -265,8 +621,10 @@ var InMemoryDatabaseAdapter = class {
 		const whereStr = m[3];
 		const table = this._tables.get(tableName);
 		if (!table) return [];
-		const assignments = this._parseAssignments(setStr);
-		for (const row of table) if (!whereStr || this._matchWhere(whereStr.trim(), row)) for (const [col, val] of assignments) row[col] = val;
+		for (const row of table) if (!whereStr || this._matchWhere(whereStr.trim(), row)) {
+			const assignments = this._parseAssignmentsForRow(setStr, row);
+			for (const [col, val] of assignments) row[col] = val;
+		}
 		return [];
 	}
 	_delete(sql) {
@@ -292,29 +650,65 @@ var InMemoryDatabaseAdapter = class {
 		const conditions = whereClause.split(/\s+AND\s+/i);
 		for (const condition of conditions) {
 			const trimmed = condition.trim();
-			const strM = /^(\w+)\s*=\s*'(.*)'$/is.exec(trimmed);
+			const strM = /^[`"]?(\w+)[`"]?\s*=\s*'(.*)'$/is.exec(trimmed);
 			if (strM) {
 				const colVal = String(row[strM[1]] ?? "");
 				const literal = strM[2].replace(/''/g, "'");
 				if (colVal !== literal) return false;
 				continue;
 			}
-			const numM = /^(\w+)\s*=\s*(-?\d+(?:\.\d+)?)$/.exec(trimmed);
+			const strNeqM = /^[`"]?(\w+)[`"]?\s*!=\s*'(.*)'$/is.exec(trimmed);
+			if (strNeqM) {
+				const colVal = String(row[strNeqM[1]] ?? "");
+				const literal = strNeqM[2].replace(/''/g, "'");
+				if (colVal === literal) return false;
+				continue;
+			}
+			const numM = /^[`"]?(\w+)[`"]?\s*=\s*(-?\d+(?:\.\d+)?)$/.exec(trimmed);
 			if (numM) {
 				if (Number(row[numM[1]]) !== parseFloat(numM[2])) return false;
 				continue;
 			}
-			const nullM = /^(\w+)\s+IS\s+NULL$/i.exec(trimmed);
+			const numNeqM = /^[`"]?(\w+)[`"]?\s*!=\s*(-?\d+(?:\.\d+)?)$/.exec(trimmed);
+			if (numNeqM) {
+				if (Number(row[numNeqM[1]]) === parseFloat(numNeqM[2])) return false;
+				continue;
+			}
+			const strCmpM = /^[`"]?(\w+)[`"]?\s*(>=|<=|>|<)\s*'(.*)'$/s.exec(trimmed);
+			if (strCmpM) {
+				const colVal = row[strCmpM[1]];
+				if (colVal === null || colVal === void 0) return false;
+				const lhs = String(colVal);
+				const rhs = strCmpM[3].replace(/''/g, "'");
+				const op = strCmpM[2];
+				if (op === "<" && !(lhs < rhs)) return false;
+				if (op === "<=" && !(lhs <= rhs)) return false;
+				if (op === ">" && !(lhs > rhs)) return false;
+				if (op === ">=" && !(lhs >= rhs)) return false;
+				continue;
+			}
+			const numCmpM = /^[`"]?(\w+)[`"]?\s*(>=|<=|>|<)\s*(-?\d+(?:\.\d+)?)$/.exec(trimmed);
+			if (numCmpM) {
+				const colVal = Number(row[numCmpM[1]] ?? 0);
+				const rhs = parseFloat(numCmpM[3]);
+				const op = numCmpM[2];
+				if (op === "<" && !(colVal < rhs)) return false;
+				if (op === "<=" && !(colVal <= rhs)) return false;
+				if (op === ">" && !(colVal > rhs)) return false;
+				if (op === ">=" && !(colVal >= rhs)) return false;
+				continue;
+			}
+			const nullM = /^[`"]?(\w+)[`"]?\s+IS\s+NULL$/i.exec(trimmed);
 			if (nullM) {
 				if (row[nullM[1]] !== null && row[nullM[1]] !== void 0) return false;
 				continue;
 			}
-			const notNullM = /^(\w+)\s+IS\s+NOT\s+NULL$/i.exec(trimmed);
+			const notNullM = /^[`"]?(\w+)[`"]?\s+IS\s+NOT\s+NULL$/i.exec(trimmed);
 			if (notNullM) {
 				if (row[notNullM[1]] === null || row[notNullM[1]] === void 0) return false;
 				continue;
 			}
-			const likeM = /^(\w+)\s+LIKE\s+'(.*)'$/is.exec(trimmed);
+			const likeM = /^[`"]?(\w+)[`"]?\s+LIKE\s+'(.*)'$/is.exec(trimmed);
 			if (likeM) {
 				const colVal = row[likeM[1]];
 				if (colVal === null || colVal === void 0) return false;
@@ -324,6 +718,22 @@ var InMemoryDatabaseAdapter = class {
 				if (!regex.test(String(colVal))) return false;
 				continue;
 			}
+			const inM = /^[`"]?(\w+)[`"]?\s+IN\s*\((.+)\)$/is.exec(trimmed);
+			if (inM) {
+				const colVal = row[inM[1]];
+				const inValues = this._parseValueList(inM[2]);
+				const colStr = colVal === null || colVal === void 0 ? null : typeof colVal === "number" ? colVal : String(colVal);
+				if (!inValues.some((v) => v === colStr || String(v) === String(colStr))) return false;
+				continue;
+			}
+			const notInM = /^[`"]?(\w+)[`"]?\s+NOT\s+IN\s*\((.+)\)$/is.exec(trimmed);
+			if (notInM) {
+				const colVal = row[notInM[1]];
+				const notInValues = this._parseValueList(notInM[2]);
+				const colStr = colVal === null || colVal === void 0 ? null : typeof colVal === "number" ? colVal : String(colVal);
+				if (notInValues.some((v) => v === colStr || String(v) === String(colStr))) return false;
+				continue;
+			}
 		}
 		return true;
 	}
@@ -333,7 +743,7 @@ var InMemoryDatabaseAdapter = class {
 		for (const col of cols) {
 			const aliasM = /^(.+?)\s+AS\s+(\w+)$/i.exec(col);
 			if (aliasM) result[aliasM[2]] = this._evalExprAgainstRow(aliasM[1].trim(), row);
-			else result[col] = row[col];
+			else result[col] = col in row ? row[col] : null;
 		}
 		return result;
 	}
@@ -413,7 +823,7 @@ var InMemoryDatabaseAdapter = class {
 	}
 	/**
 	* Evaluate a single aggregate expression against a set of rows.
-	* Supports: SUM(col), COALESCE(expr, default), COUNT(*).
+	* Supports: SUM(expr), COALESCE(expr, default), COUNT(*), MAX(col), MIN(col).
 	*/
 	_evalAggregateExpr(expr, rows) {
 		const trimmed = expr.trim();
@@ -426,20 +836,39 @@ var InMemoryDatabaseAdapter = class {
 			}
 			return null;
 		}
-		const sumM = /^SUM\((\w+)\)$/i.exec(trimmed);
+		const sumM = /^SUM\((.+)\)$/i.exec(trimmed);
 		if (sumM) {
-			const col = sumM[1];
 			if (rows.length === 0) return null;
 			let total = 0;
-			for (const row of rows) total += Number(row[col] ?? 0);
+			for (const row of rows) total += Number(this._evalRowExpr(sumM[1].trim(), row) ?? 0);
 			return total;
 		}
 		if (/^COUNT\(\*\)$/i.test(trimmed)) return rows.length;
+		const countDistinctM = /^COUNT\(\s*DISTINCT\s+(\w+)\s*\)$/i.exec(trimmed);
+		if (countDistinctM) {
+			const col = countDistinctM[1];
+			const distinct = new Set(rows.map((r) => r[col]).filter((v) => v !== null && v !== void 0));
+			return distinct.size;
+		}
 		const countM = /^COUNT\((\w+)\)$/i.exec(trimmed);
 		if (countM) {
 			const col = countM[1];
 			return rows.filter((r) => r[col] !== null && r[col] !== void 0).length;
 		}
+		const maxM = /^MAX\((\w+)\)$/i.exec(trimmed);
+		if (maxM) {
+			const col = maxM[1];
+			const values = rows.map((r) => r[col]).filter((v) => v !== null && v !== void 0);
+			if (values.length === 0) return null;
+			return values.reduce((a, b) => String(a) >= String(b) ? a : b);
+		}
+		const minM = /^MIN\((\w+)\)$/i.exec(trimmed);
+		if (minM) {
+			const col = minM[1];
+			const values = rows.map((r) => r[col]).filter((v) => v !== null && v !== void 0);
+			if (values.length === 0) return null;
+			return values.reduce((a, b) => String(a) <= String(b) ? a : b);
+		}
 		return this._evalLiteral(trimmed);
 	}
 	/**
@@ -473,8 +902,9 @@ var InMemoryDatabaseAdapter = class {
 	}
 	/**
 	* Parse `col1 = val1, col2 = val2` assignments into an array of [col, val] pairs.
+	* Evaluates each RHS expression against the provided row for arithmetic support.
 	*/
-	_parseAssignments(setStr) {
+	_parseAssignmentsForRow(setStr, row) {
 		const assignments = [];
 		const parts = [];
 		let current = "";
@@ -502,10 +932,48 @@ var InMemoryDatabaseAdapter = class {
 			if (eqIdx === -1) continue;
 			const col = part.slice(0, eqIdx).trim();
 			const valStr = part.slice(eqIdx + 1).trim();
-			assignments.push([col, this._evalLiteral(valStr)]);
+			assignments.push([col, this._evalAssignmentExpr(valStr, row)]);
 		}
 		return assignments;
 	}
+	/**
+	* Evaluate a SET assignment RHS expression against the current row.
+	* Handles: simple literals, column arithmetic (col +/- val), COALESCE, CURRENT_TIMESTAMP.
+	*/
+	_evalAssignmentExpr(expr, row) {
+		const trimmed = expr.trim();
+		if (/^CURRENT_TIMESTAMP$/i.test(trimmed)) return new Date().toISOString();
+		const coalesceM = /^COALESCE\((.+)\)$/i.exec(trimmed);
+		if (coalesceM) {
+			const args = this._splitTopLevelCommas(coalesceM[1]);
+			for (const arg of args) {
+				const val = this._evalAssignmentExpr(arg.trim(), row);
+				if (val !== null && val !== void 0) return val;
+			}
+			return null;
+		}
+		const arithM = /^(\w+)\s*([+\-*\/])\s*(-?\d+(?:\.\d+)?)$/.exec(trimmed);
+		if (arithM) {
+			const colName = arithM[1];
+			const op = arithM[2];
+			const num = parseFloat(arithM[3]);
+			const colVal = Number(row[colName] ?? 0);
+			switch (op) {
+				case "+": return colVal + num;
+				case "-": return colVal - num;
+				case "*": return colVal * num;
+				case "/": return num !== 0 ? colVal / num : null;
+			}
+		}
+		return this._evalLiteral(trimmed);
+	}
+	/**
+	* @deprecated Use _parseAssignmentsForRow instead.
+	* Kept for internal compatibility — evaluates without row context.
+	*/
+	_parseAssignments(setStr) {
+		return this._parseAssignmentsForRow(setStr, {});
+	}
 };
 
 //#endregion
@@ -2908,6 +3376,7 @@ function inspectProcessTree(opts) {
 					return parseInt(parts[0], 10) === pid && !parts[2].includes("Z");
 				});
 				if (isAlive) result.orchestrator_pid = pid;
+				else result.pid_file_dead = true;
 			}
 		} catch {}
 		if (result.orchestrator_pid === null) {
@@ -3073,7 +3542,17 @@ async function getAutoHealthData(options) {
 		await initSchema(adapter);
 		let run;
 		if (runId !== void 0) run = await getPipelineRunById(adapter, runId);
-		else run = await getLatestRun(adapter);
+		else {
+			let currentRunId;
+			try {
+				const currentRunIdPath = join(dbRoot, ".substrate", "current-run-id");
+				const content = readFileSync$1(currentRunIdPath, "utf-8").trim();
+				const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+				if (UUID_RE.test(content)) currentRunId = content;
+			} catch {}
+			if (currentRunId !== void 0) run = await getPipelineRunById(adapter, currentRunId);
+			if (run === void 0) run = await getLatestRun(adapter);
+		}
 		if (run === void 0) {
 			const substrateDirPath$1 = join(dbRoot, ".substrate");
 			const fallbackProcessInfo = inspectProcessTree({
@@ -3121,16 +3600,16 @@ async function getAutoHealthData(options) {
 			}
 		} catch {}
 		const substrateDirPath = join(dbRoot, ".substrate");
-		const processInfo = inspectProcessTree({
+		const processInfo = options._processInfoOverride ?? inspectProcessTree({
 			projectRoot,
 			substrateDirPath
 		});
 		let verdict = "NO_PIPELINE_RUNNING";
-		if (run.status === "running") if (processInfo.zombies.length > 0) verdict = "STALLED";
-		else if (processInfo.orchestrator_pid !== null && processInfo.child_pids.length > 0 && stalenessSeconds > DEFAULT_STALL_THRESHOLD_SECONDS) verdict = "HEALTHY";
+		if (run.status === "running") if (processInfo.orchestrator_pid !== null) verdict = "HEALTHY";
+		else if (processInfo.pid_file_dead === true) verdict = "STALLED";
+		else if (processInfo.zombies.length > 0) verdict = "STALLED";
 		else if (stalenessSeconds > DEFAULT_STALL_THRESHOLD_SECONDS) verdict = "STALLED";
-		else if (processInfo.orchestrator_pid !== null && processInfo.child_pids.length === 0 && active > 0) verdict = "STALLED";
-		else if (processInfo.orchestrator_pid === null && active > 0) verdict = "STALLED";
+		else if (active > 0) verdict = "STALLED";
 		else verdict = "HEALTHY";
 		else if (run.status === "completed" || run.status === "failed" || run.status === "stopped") verdict = "NO_PIPELINE_RUNNING";
 		const healthOutput = {
@@ -3244,4 +3723,4 @@ function registerHealthCommand(program, _version = "0.0.0", projectRoot = proces
 
 //#endregion
 export { BMAD_BASELINE_TOKENS_FULL, DEFAULT_STALL_THRESHOLD_SECONDS, DoltClient, DoltMergeConflict, DoltNotInstalled, FileStateStore, STOP_AFTER_VALID_PHASES, STORY_KEY_PATTERN$1 as STORY_KEY_PATTERN, SUBSTRATE_OWNED_SETTINGS_KEYS, VALID_PHASES, WorkGraphRepository, __commonJS, __require, __toESM, buildPipelineStatusOutput, checkDoltInstalled, createDatabaseAdapter, createDoltClient, createStateStore, detectCycles, findPackageRoot, formatOutput, formatPipelineStatusHuman, formatPipelineSummary, formatTokenTelemetry, getAllDescendantPids, getAutoHealthData, getSubstrateDefaultSettings, initSchema, initializeDolt, inspectProcessTree, isOrchestratorProcessLine, isSyncAdapter, parseDbTimestampAsUtc, registerHealthCommand, resolveBmadMethodSrcPath, resolveBmadMethodVersion, resolveMainRepoRoot, runHealthAction, validateStoryKey };
-//# sourceMappingURL=health-Dnx-FGva.js.map
+//# sourceMappingURL=health-C-VRJruD.js.map