@cleocode/cleo 2026.9.7 → 2026.9.10

package/studio-dist/server/chunks/role-resolver2-nkhzS1oy.js

@@ -1,37 +0,0 @@
-export { I as IMPLICIT_FALLBACK_MODEL } from './config-DHj9CcFs.js';
-import { r as resolveLLMForRole } from './role-resolver-D9QaDT0e.js';
-export { H as HYGIENE_FALLBACK_MODEL, a as resolveAnthropicForRole } from './role-resolver-D9QaDT0e.js';
-import './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './json-Bfixam3g.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-import 'node:fs/promises';
-import './index-61916rmV.js';
-import './credential-pool-vF6NdtT9.js';
-
-
-
-export { resolveLLMForRole };
-//# sourceMappingURL=role-resolver2-nkhzS1oy.js.map

package/studio-dist/server/chunks/rollup-CiefjN_Y.js

@@ -1,194 +0,0 @@
-import { b as getNativeTasksDb } from './sqlite-Bm5LzbPs.js';
-
-//#region ../core/dist/lifecycle/rollup.js
-/**
-* Task rollup — canonical view of a task's execution + pipeline + children state.
-*
-* `computeTaskRollup` is the SINGLE source of truth consumed by Studio, the
-* SDK, and the CLI for answering "what is the state of this task?" Prior to
-* T943 each surface independently stitched together `tasks.status`,
-* `tasks.pipelineStage`, child counts, and gate results, producing divergent
-* views (e.g. `/tasks` vs `/tasks/pipeline` disagreeing about epic progress).
-*
-* Design contract:
-*   - Pure read — no writes, no side effects.
-*   - `pipelineStage` reads `tasks.pipelineStage` directly until T947 migrates
-*     it to the derived lifecycle view.
-*   - Archived children are EXCLUDED from both `childrenTotal` and
-*     `childrenDone` so epic-progress bars reflect in-flight scope.
-*   - `gatesVerified` is populated only when `lifecycle_gate_results` has at
-*     least one `result='pass'` row linked to a stage owned by this task's
-*     pipeline. Missing rows → empty array.
-*   - `blockedBy` parses `tasks.blocked_by` robustly: JSON array, falling back
-*     to comma-separated tokens, falling back to the raw string, and
-*     collapsing to `[]` on empty/null.
-*   - Batch API (`computeTaskRollups`) preserves input order and returns the
-*     entries for missing task IDs as `null`-free by filtering them out. The
-*     caller can re-align using the returned `id`s.
-*
-* @task T943
-*/
-/**
-* Parse the `tasks.blocked_by` text column into a canonical string array.
-*
-* Strategy (first match wins):
-*   1. Non-empty JSON array of strings → use as-is after trimming.
-*   2. Comma-separated list → split + trim + drop empties.
-*   3. Single non-empty token → wrap in a one-element array.
-*   4. Null / empty / whitespace-only → empty array.
-*
-* Never throws; silently falls back to the next strategy on parse error.
-*/
-function parseBlockedBy(raw) {
-	if (raw === null || raw === void 0) return [];
-	const trimmed = raw.trim();
-	if (trimmed.length === 0) return [];
-	if (trimmed.startsWith("[")) try {
-		const parsed = JSON.parse(trimmed);
-		if (Array.isArray(parsed)) return parsed.filter((v) => typeof v === "string").map((v) => v.trim()).filter((v) => v.length > 0);
-	} catch {}
-	if (trimmed.includes(",")) return trimmed.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
-	return [trimmed];
-}
-/**
-* Compute the `lastActivityAt` timestamp.
-*
-* Preference order: `completedAt` vs `updatedAt`, whichever is lexicographically
-* greater (ISO-8601 strings sort correctly when both use the same zone).
-* Returns `null` when neither is set.
-*/
-function computeLastActivityAt(updatedAt, completedAt) {
-	const u = updatedAt ?? null;
-	const c = completedAt ?? null;
-	if (u === null && c === null) return null;
-	if (u === null) return c;
-	if (c === null) return u;
-	return u >= c ? u : c;
-}
-/**
-* Normalise a raw `tasks.status` enum value into a {@link RollupExecStatus}.
-*
-* Every value the DB CHECK constraint allows is already a member of the
-* rollup union, so this is a pure widening cast — but we keep it centralised
-* so the T947 migration (`proposed` from external intake) has one place to
-* hook into.
-*/
-function toRollupExecStatus(status) {
-	return status;
-}
-/**
-* Aggregate non-archived children per parent in a single query.
-*
-* Returns a map keyed by parent_id with `{ total, done }` counts. Parents with
-* zero non-archived children are omitted so the caller defaults to 0.
-*/
-function fetchChildAggregates(taskIds) {
-	const empty = /* @__PURE__ */ new Map();
-	if (taskIds.length === 0) return empty;
-	const native = getNativeTasksDb();
-	if (!native) return empty;
-	const sqlText = `
-    SELECT
-      parent_id           AS parent_id,
-      COUNT(*)            AS children_total,
-      SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) AS children_done
-    FROM tasks_tasks
-    WHERE parent_id IN (${taskIds.map(() => "?").join(", ")})
-      AND status != 'archived'
-    GROUP BY parent_id
-  `;
-	const rows = native.prepare(sqlText).all(...taskIds);
-	const map = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (row.parent_id === null) continue;
-		map.set(row.parent_id, {
-			total: Number(row.children_total ?? 0),
-			done: Number(row.children_done ?? 0)
-		});
-	}
-	return map;
-}
-/**
-* Fetch gate names with `result='pass'` for every task in a single query.
-*
-* Joins `lifecycle_gate_results` → `lifecycle_stages` → `lifecycle_pipelines`
-* and filters by `pipelines.task_id`. Returns `[]` per-task when the task has
-* no pipeline or when every gate result is non-pass.
-*/
-function fetchPassedGateNames(taskIds) {
-	const empty = /* @__PURE__ */ new Map();
-	if (taskIds.length === 0) return empty;
-	const native = getNativeTasksDb();
-	if (!native) return empty;
-	const sqlText = `
-    SELECT DISTINCT
-      p.task_id   AS task_id,
-      g.gate_name AS gate_name
-    FROM tasks_lifecycle_gate_results g
-    INNER JOIN tasks_lifecycle_stages s     ON s.id = g.stage_id
-    INNER JOIN tasks_lifecycle_pipelines p  ON p.id = s.pipeline_id
-    WHERE p.task_id IN (${taskIds.map(() => "?").join(", ")})
-      AND g.result = 'pass'
-    ORDER BY g.gate_name ASC
-  `;
-	let rows;
-	try {
-		rows = native.prepare(sqlText).all(...taskIds);
-	} catch {
-		return empty;
-	}
-	const map = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		if (row.task_id === null || row.gate_name === null) continue;
-		const list = map.get(row.task_id);
-		if (list === void 0) map.set(row.task_id, [row.gate_name]);
-		else if (!list.includes(row.gate_name)) list.push(row.gate_name);
-	}
-	return map;
-}
-/**
-* Assemble a {@link TaskRollup} from its raw inputs.
-*/
-function buildRollup(task, childAggregate, gatesVerified) {
-	return {
-		id: task.id,
-		execStatus: toRollupExecStatus(task.status),
-		pipelineStage: task.pipelineStage ?? null,
-		gatesVerified,
-		childrenTotal: childAggregate?.total ?? 0,
-		childrenDone: childAggregate?.done ?? 0,
-		blockedBy: parseBlockedBy(task.blockedBy),
-		lastActivityAt: computeLastActivityAt(task.updatedAt, task.completedAt)
-	};
-}
-/**
-* Compute rollups for many tasks in a single batch.
-*
-* Issues exactly one task load, one child-aggregate query, and one gate query
-* regardless of batch size. Results preserve the input order of `taskIds`.
-* Missing IDs are omitted from the return array — the caller can detect them
-* by comparing `taskIds.length` vs `result.length` or by mapping on `id`.
-*
-* @param taskIds - Ordered list of task identifiers to roll up.
-* @param dataAccessor - Storage accessor used for the batched task load.
-* @returns Rollups in the same order as `taskIds`, minus any missing ids.
-*/
-async function computeTaskRollups(taskIds, dataAccessor) {
-	if (taskIds.length === 0) return [];
-	const loaded = await dataAccessor.loadTasks(taskIds);
-	const byId = /* @__PURE__ */ new Map();
-	for (const task of loaded) byId.set(task.id, task);
-	const presentIds = taskIds.filter((id) => byId.has(id));
-	const childMap = fetchChildAggregates(presentIds);
-	const gateMap = fetchPassedGateNames(presentIds);
-	const rollups = [];
-	for (const id of taskIds) {
-		const task = byId.get(id);
-		if (task === void 0) continue;
-		rollups.push(buildRollup(task, childMap.get(id), gateMap.get(id) ?? []));
-	}
-	return rollups;
-}
-
-export { computeTaskRollups as c };
-//# sourceMappingURL=rollup-CiefjN_Y.js.map

package/studio-dist/server/chunks/safety-data-accessor-CniDmGJO.js

@@ -1,276 +0,0 @@
-import { b as getLogger } from './paths-CV7S5-Zm.js';
-import { s as safeSaveSessions, a as safeSaveArchive, b as safeAppendLog, c as safeSingleTaskWrite } from './data-safety-central-DaFxK27G.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './sqlite-Bm5LzbPs.js';
-import './dual-scope-db-DKnWu1KM.js';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './nexus-sqlite2-BBfY2xnY.js';
-import './nexus-schema2-DP0Qd7CA.js';
-import './chunk-DDP5xfzh.js';
-import './logger-DQIoyZbq.js';
-import 'node:sqlite';
-import './unique-constraint-BZrrwgwc.js';
-import './lock-CA7d6lj7.js';
-import './index-Dtt_h58T.js';
-import 'constants';
-import 'stream';
-import './json-Bfixam3g.js';
-import 'node:fs/promises';
-import './index-61916rmV.js';
-import './data-accessor-CWgVndbR.js';
-import './sqlite-data-accessor-DD_RFX6r.js';
-import './session-store--N_xHxUH.js';
-import './cross-db-cleanup-1LWTUKPi.js';
-import 'node:util';
-
-//#region ../core/dist/store/safety-data-accessor.js
-/**
-* SafetyDataAccessor - Factory-level safety wrapper for ALL data accessors.
-*
-* This wrapper ensures that ALL data operations are safety-enabled by default.
-* No code path can bypass safety - this is the architectural guarantee.
-*
-* Key features:
-* - Sequence validation before writes
-* - Write verification (read-back validation)
-* - Automatic git checkpointing
-* - Emergency disable via CLEO_DISABLE_SAFETY env var
-*
-* @task T4745
-* @epic T4732
-*/
-var log = getLogger("data-safety");
-/** Check if safety is disabled via environment variable. */
-function isSafetyDisabled() {
-	return process.env.CLEO_DISABLE_SAFETY === "true";
-}
-/**
-* Safety-enabled DataAccessor wrapper.
-*
-* Wraps any DataAccessor implementation and automatically applies
-* safety checks to all write operations. Read operations pass through.
-*
-* This class CANNOT be bypassed - it's the only way to get a DataAccessor
-* from the factory (unless emergency disable is active).
-*/
-var SafetyDataAccessor = class {
-	/** The underlying accessor being wrapped. */
-	inner;
-	/** Working directory for operations. */
-	cwd;
-	/** Safety configuration. */
-	config;
-	/**
-	* Create a SafetyDataAccessor wrapper.
-	*
-	* @param inner - The DataAccessor to wrap
-	* @param cwd - Working directory for path resolution
-	* @param config - Optional safety configuration overrides
-	*/
-	constructor(inner, cwd, config) {
-		this.inner = inner;
-		this.cwd = cwd;
-		this.config = {
-			enabled: true,
-			verbose: false,
-			...config
-		};
-		if (this.config.verbose) log.debug({ engine: inner.engine }, "SafetyDataAccessor initialized");
-	}
-	/** The storage engine backing this accessor. */
-	get engine() {
-		return this.inner.engine;
-	}
-	/**
-	* Log safety operation if verbose mode is enabled.
-	*/
-	logVerbose(message) {
-		if (this.config.verbose) log.debug(message);
-	}
-	/**
-	* Get safety options for data-safety-central operations.
-	*/
-	getSafetyOptions() {
-		return {
-			verify: this.config.enabled,
-			checkpoint: this.config.enabled,
-			validateSequence: this.config.enabled,
-			strict: this.config.enabled
-		};
-	}
-	async loadArchive() {
-		this.logVerbose("Loading ArchiveFile (pass-through)");
-		return this.inner.loadArchive();
-	}
-	async loadSessions() {
-		this.logVerbose("Loading sessions (pass-through)");
-		return this.inner.loadSessions();
-	}
-	async saveSessions(data) {
-		this.logVerbose(`Saving sessions with ${data.length} sessions`);
-		await safeSaveSessions(this.inner, data, this.cwd, this.getSafetyOptions());
-	}
-	async saveArchive(data) {
-		this.logVerbose(`Saving ArchiveFile with ${data.archivedTasks?.length ?? 0} tasks`);
-		await safeSaveArchive(this.inner, data, this.cwd, this.getSafetyOptions());
-	}
-	async appendLog(entry) {
-		this.logVerbose("Appending log entry");
-		await safeAppendLog(this.inner, entry, this.cwd, this.getSafetyOptions());
-	}
-	async upsertSingleTask(task) {
-		this.logVerbose(`Upserting single task ${task.id}`);
-		await safeSingleTaskWrite(this.inner, task.id, () => this.inner.upsertSingleTask(task), this.cwd, this.getSafetyOptions());
-	}
-	async archiveSingleTask(taskId, fields) {
-		this.logVerbose(`Archiving single task ${taskId}`);
-		await safeSingleTaskWrite(this.inner, taskId, () => this.inner.archiveSingleTask(taskId, fields), this.cwd, this.getSafetyOptions());
-	}
-	async removeSingleTask(taskId) {
-		this.logVerbose(`Removing single task ${taskId}`);
-		await safeSingleTaskWrite(this.inner, taskId, () => this.inner.removeSingleTask(taskId), this.cwd, this.getSafetyOptions());
-	}
-	async loadSingleTask(taskId) {
-		return this.inner.loadSingleTask(taskId);
-	}
-	async addRelation(taskId, relatedTo, relationType, reason) {
-		await this.inner.addRelation(taskId, relatedTo, relationType, reason);
-	}
-	async removeRelation(taskId, relatedTo, relationType) {
-		await this.inner.removeRelation(taskId, relatedTo, relationType);
-	}
-	async getAcRows(taskId) {
-		return this.inner.getAcRows(taskId);
-	}
-	async getAcBindings(acIds) {
-		return this.inner.getAcBindings(acIds);
-	}
-	async getMetaValue(key) {
-		return this.inner.getMetaValue(key);
-	}
-	async setMetaValue(key, value) {
-		return this.inner.setMetaValue(key, value);
-	}
-	async getSchemaVersion() {
-		return this.inner.getSchemaVersion();
-	}
-	async queryTasks(filters) {
-		return this.inner.queryTasks(filters);
-	}
-	async queryAuditLog(query) {
-		return this.inner.queryAuditLog(query);
-	}
-	async countTasks(filters) {
-		return this.inner.countTasks(filters);
-	}
-	async getChildren(parentId) {
-		return this.inner.getChildren(parentId);
-	}
-	async countChildren(parentId) {
-		return this.inner.countChildren(parentId);
-	}
-	async countActiveChildren(parentId) {
-		return this.inner.countActiveChildren(parentId);
-	}
-	async getAncestorChain(taskId) {
-		return this.inner.getAncestorChain(taskId);
-	}
-	async getSubtree(rootId) {
-		return this.inner.getSubtree(rootId);
-	}
-	async getDependents(taskId) {
-		return this.inner.getDependents(taskId);
-	}
-	async getDependencyChain(taskId) {
-		return this.inner.getDependencyChain(taskId);
-	}
-	async taskExists(taskId) {
-		return this.inner.taskExists(taskId);
-	}
-	async loadTasks(taskIds) {
-		return this.inner.loadTasks(taskIds);
-	}
-	async updateTaskFields(taskId, fields) {
-		this.logVerbose(`Updating fields on task ${taskId}`);
-		await safeSingleTaskWrite(this.inner, taskId, () => this.inner.updateTaskFields(taskId, fields), this.cwd, this.getSafetyOptions());
-	}
-	async getNextPosition(parentId) {
-		return this.inner.getNextPosition(parentId);
-	}
-	async shiftPositions(parentId, fromPosition, delta) {
-		return this.inner.shiftPositions(parentId, fromPosition, delta);
-	}
-	async transaction(fn) {
-		this.logVerbose("Starting transaction");
-		return this.inner.transaction(fn);
-	}
-	async getActiveSession() {
-		return this.inner.getActiveSession();
-	}
-	async resolveCurrentSession() {
-		return this.inner.resolveCurrentSession();
-	}
-	async upsertSingleSession(session) {
-		return this.inner.upsertSingleSession(session);
-	}
-	async removeSingleSession(sessionId) {
-		return this.inner.removeSingleSession(sessionId);
-	}
-	async listAgentInstances(filters) {
-		return this.inner.listAgentInstances(filters);
-	}
-	async getAgentInstance(agentId) {
-		return this.inner.getAgentInstance(agentId);
-	}
-	async claimTask(taskId, agentId) {
-		return this.inner.claimTask(taskId, agentId);
-	}
-	async unclaimTask(taskId) {
-		return this.inner.unclaimTask(taskId);
-	}
-	async close() {
-		this.logVerbose("Closing accessor");
-		await this.inner.close();
-	}
-};
-/**
-* Wrap a DataAccessor with safety.
-*
-* This is the internal factory helper that wraps any accessor
-* with the SafetyDataAccessor wrapper.
-*
-* @param accessor - The accessor to wrap
-* @param cwd - Working directory
-* @returns SafetyDataAccessor wrapping the input
-*/
-function wrapWithSafety(accessor, cwd) {
-	if (isSafetyDisabled()) {
-		log.warn("Safety disabled - emergency mode (CLEO_DISABLE_SAFETY=true). Data integrity checks bypassed.");
-		return accessor;
-	}
-	return new SafetyDataAccessor(accessor, cwd);
-}
-
-export { wrapWithSafety };
-//# sourceMappingURL=safety-data-accessor-CniDmGJO.js.map