@cleocode/cleo 2026.9.7 → 2026.9.9

package/studio-dist/server/chunks/service-connections-accessor-yBCdcgU-.js

@@ -1,282 +0,0 @@
-import { d as openDualScopeDb } from './dual-scope-db-DKnWu1KM.js';
-import './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:crypto';
-import 'node:child_process';
-import { s as sqliteTable, t as text, i as integer, a as index } from './indexes-DZ52grq6.js';
-import { u as unique, p as primaryKey } from './unique-constraint-BZrrwgwc.js';
-import 'node:fs/promises';
-import { s as sql } from './utils-BPSZyajG.js';
-
-/**
-* `service_connections` — one user-connected service credential per `(provider, label)`.
-*
-* `credentials_enc` is the `encryptGlobal()` ciphertext of the
-* `{access_token, refresh_token}` JSON blob (NEVER plaintext). `scopes` is the
-* JSON-serialized granted scope list; `metadata` is non-secret JSON (e.g. the
-* connected `username`/`email`) safe to display. The `(provider, label)` pair is
-* unique. The OAuth build/exchange/refresh that POPULATES `credentials_enc` is
-* T11939 — this table is the clean seam it writes into.
-*
-* @task T11937
-*/
-var serviceConnections = sqliteTable("service_connections", {
-	id: integer("id").primaryKey(),
-	provider: text("provider").notNull(),
-	label: text("label").notNull(),
-	status: text("status", { enum: [
-		"active",
-		"expired",
-		"revoked"
-	] }).notNull().default("active"),
-	credentialsEnc: text("credentials_enc"),
-	scopes: text("scopes").notNull().default("[]"),
-	expiresAt: text("expires_at"),
-	metadata: text("metadata").notNull().default("{}"),
-	connectedAt: text("connected_at").notNull().default(sql`(datetime('now'))`),
-	updatedAt: text("updated_at").notNull().default(sql`(datetime('now'))`)
-}, (table) => [unique("ux_service_connections_provider_label").on(table.provider, table.label), index("idx_service_connections_provider_status").on(table.provider, table.status)]);
-sqliteTable("service_configs", {
-	id: integer("id").primaryKey(),
-	provider: text("provider").notNull(),
-	enabled: integer("enabled", { mode: "boolean" }).notNull().default(false),
-	clientSecretEnc: text("client_secret_enc"),
-	settings: text("settings").notNull().default("{}"),
-	createdAt: text("created_at").notNull().default(sql`(datetime('now'))`),
-	updatedAt: text("updated_at").notNull().default(sql`(datetime('now'))`)
-}, (table) => [unique("ux_service_configs_provider").on(table.provider)]);
-/**
-* `agent_service_grants` — per-agent access to a service connection + policy.
-*
-* A grant authorizes one `agent_id` to use one `service_connection_id`, carrying
-* the `session_policy` JSON (block / rate-limit / manual-approval) the trust gate
-* (T11937 AC4) evaluates BEFORE any `decryptGlobal`. ABSENCE of a grant denies;
-* a `block` policy denies; only a passing policy lets the store decrypt. The
-* composite `(agent_id, service_connection_id)` is the primary key.
-*
-* `service_connection_id` references `service_connections(id)` — both tables live
-* in the SAME global `cleo.db` file (Pattern A), so the FK is in-file and
-* enforceable. The FK is declared natively (intra-domain, single global file —
-* mirrors the agent-registry FK convention).
-*
-* @task T11937
-*/
-var agentServiceGrants = sqliteTable("agent_service_grants", {
-	agentId: text("agent_id").notNull(),
-	serviceConnectionId: integer("service_connection_id").notNull().references(() => serviceConnections.id),
-	sessionPolicy: text("session_policy").notNull().default("{\"mode\":\"allow\"}"),
-	createdAt: text("created_at").notNull().default(sql`(datetime('now'))`),
-	updatedAt: text("updated_at").notNull().default(sql`(datetime('now'))`)
-}, (table) => [primaryKey({ columns: [table.agentId, table.serviceConnectionId] }), index("idx_agent_service_grants_agent").on(table.agentId)]);
-//#endregion
-//#region ../core/dist/store/service-trust-gate.js
-/**
-* Service-vault trust gate — **policy-before-decrypt** per-agent access control.
-*
-* EP-UNIVERSAL-SERVICE-VAULT (epic T11765 · saga SG-VAULT-CORE T10409 · M2 W1a ·
-* task T11937 · AC4). Ports onecli `connect.rs` selective-mode: an agent may use a
-* service connection ONLY when (a) a row exists in `agent_service_grants` linking
-* the agent to the connection, AND (b) the grant's `session_policy` evaluates to
-* an allow. This module evaluates that decision from already-loaded grant data —
-* it performs ZERO crypto. The store
-* ({@link import('./service-connections-accessor.js')}) calls `decryptGlobal`
-* ONLY after this gate returns `allowed: true`, so a denied/blocked agent NEVER
-* triggers a decrypt (the policy-before-decrypt invariant, proven by unit test).
-*
-* ## Why the gate is decrypt-free
-*
-* The gate takes the grant rows as INPUT and returns a pure decision. It cannot
-* decrypt even if it wanted to — it imports no crypto. The decryption chokepoint
-* lives one layer up (the accessor), guarded by this decision. That separation is
-* exactly what makes "a denied agent never decrypts" structurally true and
-* spy-assertable: the spy is placed on `decryptGlobal`, and a deny path returns
-* before the accessor reaches the decrypt call.
-*
-* ## Policy shape ({@link SessionPolicy})
-*
-* Mirrors onecli's `PolicyAction` (block / rate-limit / manual-approval) collapsed
-* to a per-grant JSON:
-*
-*   - `mode: 'allow' | 'block'` — `block` is a hard deny (no decrypt).
-*   - `rateLimit?` — advisory rate cap; the gate surfaces it but does not itself
-*     count requests (the caller enforces). Presence alone does not deny.
-*   - `manualApproval?: true` — the connection requires an out-of-band human
-*     approval that has not been granted for this session → deny (no decrypt)
-*     until the caller supplies `approved: true` in the evaluation context.
-*
-* A bare grant (`{"mode":"allow"}`, the column default) allows.
-*
-* @module store/service-trust-gate
-* @task T11937
-* @epic T11765
-* @saga T10409
-* @see ./service-connections-accessor.ts — the accessor that decrypts ONLY on allow
-* @see ../../../onecli — `apps/gateway/src/connect.rs` selective-mode (the ported model)
-*/
-/**
-* Parse a raw `session_policy` JSON string into a {@link SessionPolicy}, failing
-* CLOSED (to `block`) on any malformed input.
-*
-* SECURITY: a corrupt/unparseable policy must NEVER silently widen access — it
-* resolves to `{ mode: 'block' }` so the gate denies and no decrypt occurs.
-*
-* @param raw - The `agent_service_grants.session_policy` column value.
-* @returns A well-formed {@link SessionPolicy}; `block` on parse failure.
-* @task T11937
-*/
-function parseSessionPolicy(raw) {
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return { mode: "block" };
-	}
-	if (typeof parsed !== "object" || parsed === null) return { mode: "block" };
-	const obj = parsed;
-	const policy = { mode: obj["mode"] === "block" ? "block" : obj["mode"] === "allow" ? "allow" : "block" };
-	if (obj["manualApproval"] === true) policy.manualApproval = true;
-	const rl = obj["rateLimit"];
-	if (typeof rl === "object" && rl !== null) {
-		const rlObj = rl;
-		const maxRequests = rlObj["maxRequests"];
-		const window = rlObj["window"];
-		if (typeof maxRequests === "number" && maxRequests > 0 && (window === "minute" || window === "hour" || window === "day")) policy.rateLimit = {
-			maxRequests,
-			window
-		};
-	}
-	return policy;
-}
-//#endregion
-//#region ../core/dist/store/service-connections-accessor.js
-/**
-* Service-vault accessor — store-level CRUD + policy-before-decrypt egress.
-*
-* EP-UNIVERSAL-SERVICE-VAULT (epic T11765 · saga SG-VAULT-CORE T10409 · M2 W1a ·
-* task T11937 · AC3). The store layer for the universal SERVICE-credential vault
-* (`service_connections` / `service_configs` / `agent_service_grants`).
-*
-* ## DB Open Guard (Gate 3 — strict)
-*
-* EVERY open goes through {@link openDualScopeDb}`('global')` (or its path-aware
-* sibling {@link openDualScopeDbAtPath} for an injected test DB) — there is ZERO
-* raw `new DatabaseSync(`. The typed Drizzle handle drives all CRUD; the accessor
-* never constructs a native handle itself.
-*
-* ## Crypto reuse (DRY — no new crypto · T11710)
-*
-* `credentials_enc` holds the {@link encryptGlobal} ciphertext of the
-* `{access_token, refresh_token}` JSON, keyed `id = service:${provider}:${label}`.
-* The accessor calls {@link encryptGlobal}/{@link decryptGlobal} from
-* `crypto/credentials.ts` — it adds no crypto of its own. The crypto functions are
-* injectable ({@link ServiceVaultDeps}) so a test can spy on `decryptGlobal` and
-* PROVE it is never invoked on a denied access (policy-before-decrypt, AC4).
-*
-* ## Policy-before-decrypt egress (AC4)
-*
-* {@link resolveSealedConnection} evaluates the {@link evaluateServiceAccess}
-* trust gate FIRST (a pure decision from the agent's grant rows). It calls
-* `decryptGlobal` ONLY when the gate returns `allowed: true`. A denied agent
-* returns `null` BEFORE the decrypt call — the decrypt closure never runs. On
-* allow, the plaintext is not surfaced inline: it is wrapped in a
-* {@link makeSealedCredential} handle whose `resolveToken` thunk performs the
-* decrypt at the wire (the same egress the LLM credential pool uses).
-*
-* ## OAuth seam (T11939)
-*
-* The OAuth build/exchange/refresh dance is the FOLLOW-UP (T11939). This accessor
-* leaves the clean seam: {@link connectService} accepts an already-obtained token
-* blob and writes its `encryptGlobal` ciphertext into `credentials_enc`; the OAuth
-* flow simply calls `connectService` (or `updateConnectionCredentials`) with the
-* tokens it negotiates. No OAuth logic lives here.
-*
-* @module store/service-connections-accessor
-* @task T11937
-* @epic T11765
-* @saga T10409
-* @see ./schema/cleo-global/services.ts — the three tables
-* @see ./service-trust-gate.ts — the policy-before-decrypt decision
-* @see ../crypto/credentials.ts — `encryptGlobal` / `decryptGlobal` (reused, not re-implemented)
-* @see ../llm/sealed-credential.ts — `makeSealedCredential` (the shared egress handle)
-*/
-/** Resolve the global Drizzle handle — injected, else canonical open. */
-async function resolveDb(deps) {
-	return (await openDualScopeDb("global")).db;
-}
-/** Map a raw connection row to a non-secret {@link ServiceConnectionView}. */
-function toView(row) {
-	let scopes = [];
-	let metadata = {};
-	try {
-		const parsed = JSON.parse(row.scopes);
-		if (Array.isArray(parsed)) scopes = parsed.filter((s) => typeof s === "string");
-	} catch {}
-	try {
-		const parsed = JSON.parse(row.metadata);
-		if (typeof parsed === "object" && parsed !== null) metadata = parsed;
-	} catch {}
-	return {
-		id: row.id,
-		provider: row.provider,
-		label: row.label,
-		status: row.status,
-		scopes,
-		expiresAt: row.expiresAt,
-		metadata,
-		connectedAt: row.connectedAt,
-		updatedAt: row.updatedAt,
-		hasCredentials: row.credentialsEnc !== null && row.credentialsEnc !== ""
-	};
-}
-/**
-* LIST connections as non-secret views (NEVER decrypts), optionally by provider.
-*
-* @param provider - When set, restrict to one provider; otherwise all.
-* @task T11937
-*/
-async function listConnections(provider, deps) {
-	const db = await resolveDb();
-	return (await db.select().from(serviceConnections) ).map(toView);
-}
-/**
-* LIST every agent grant as a NON-SECRET {@link AgentGrantView}, joined to its
-* connection's `provider`/`label` for display. NEVER decrypts and never carries
-* a token — the dashboard read path (T11943).
-*
-* The join is performed in-memory (one `agent_service_grants` scan + one
-* `service_connections` scan, both already redacted) so the accessor stays a
-* pure read with no second round-trip per grant. A grant whose connection was
-* deleted out-of-band resolves `provider`/`label` to `null` (defensive — the
-* cascade should prevent this, but the view must not throw).
-*
-* @param agentId - When set, restrict to one agent's grants; otherwise all.
-* @task T11943
-*/
-async function listAllGrants(agentId, deps) {
-	const db = await resolveDb();
-	const grantRows = await db.select().from(agentServiceGrants) ;
-	const connRows = await db.select().from(serviceConnections);
-	const identityById = /* @__PURE__ */ new Map();
-	for (const c of connRows) identityById.set(c.id, {
-		provider: c.provider,
-		label: c.label
-	});
-	return grantRows.map((g) => {
-		const identity = identityById.get(g.serviceConnectionId) ?? null;
-		const policy = parseSessionPolicy(g.sessionPolicy);
-		return {
-			agentId: g.agentId,
-			serviceConnectionId: g.serviceConnectionId,
-			provider: identity?.provider ?? null,
-			label: identity?.label ?? null,
-			mode: policy.mode,
-			manualApproval: policy.manualApproval ?? false,
-			createdAt: g.createdAt,
-			updatedAt: g.updatedAt
-		};
-	});
-}
-
-export { listAllGrants as a, listConnections as l };
-//# sourceMappingURL=service-connections-accessor-yBCdcgU-.js.map

package/studio-dist/server/chunks/session-factory-vbengc42.js

@@ -1,96 +0,0 @@
-import { D as DefaultLlmSessionFactory } from './dist4-DmC1zSXi.js';
-import 'node:module';
-import './dual-scope-db-DKnWu1KM.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:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-import './indexes-DZ52grq6.js';
-import './utils-BPSZyajG.js';
-import './query-promise-BkPmGPJy.js';
-import './adapters-BkMgPNUM.js';
-import './registry2-DoPYJnUW.js';
-import './data-accessor-CWgVndbR.js';
-import './tasks-SHX7UPGY.js';
-import './sqlite-Bm5LzbPs.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 'node:fs/promises';
-import 'jsonc-parser';
-import '@cleocode/cant';
-import 'node:util';
-import 'node:buffer';
-import 'child_process';
-import './branch-lock-Cq7zzmFK.js';
-import './src2-DK8DKufK.js';
-import 'llmtxt/identity';
-import './sessions-33DD4hkt.js';
-import './index-61916rmV.js';
-import './mvi-helpers-BNsJ8ZpQ.js';
-import './session-store--N_xHxUH.js';
-import './storage-B9UA3BHR.js';
-import './config-DHj9CcFs.js';
-import './json-Bfixam3g.js';
-import './data-safety-central-DaFxK27G.js';
-import './sqlite-data-accessor-DD_RFX6r.js';
-import './cross-db-cleanup-1LWTUKPi.js';
-import './query-ops-DCrjbZb9.js';
-import 'node:net';
-import './src3-BJjf7XRG.js';
-import './local-model-fit2-BMqo6GJm.js';
-import './credential-pool-vF6NdtT9.js';
-import './catalog-model-resolver2-Cexk2TN0.js';
-import './role-resolver-D9QaDT0e.js';
-import './identity2-DeAB5RXE.js';
-import './role-executor-CC8BU54L.js';
-import 'node:stream';
-import 'crypto';
-import 'os';
-import 'node:http2';
-import 'fs/promises';
-import './catalog-resolver-CLot3XJO.js';
-import './brain-maintenance-U6VvsvmK.js';
-import './graph-auto-populate2-Cz0qeebM.js';
-import './temporal-supersession-DP4GPG_B.js';
-import './typed-query-l1D_QElt.js';
-import './llm-backend-resolver-D4ANvUPL.js';
-import '@ai-sdk/provider-utils';
-import './observer-reflector2-ggtC1hmk.js';
-import './learnings2-MwBdR9vb.js';
-import './memory-accessor2-B981tHDR.js';
-import './quality-scoring-CCPuRQmJ.js';
-import './patterns2-CzIcT-ai.js';
-import './graph-memory-bridge2-Cd0XZwqc.js';
-import './sigil2-jRMG5DuR.js';
-import './service-connections-accessor-yBCdcgU-.js';
-import './audit3-DMO_fUGp.js';
-import 'process';
-
-
-
-export { DefaultLlmSessionFactory };
-//# sourceMappingURL=session-factory-vbengc42.js.map

package/studio-dist/server/chunks/session-grade-BF4ZZtN_.js

@@ -1,244 +0,0 @@
-import { p as getCleoDirAbsolute } from './paths-CV7S5-Zm.js';
-import { q as queryAudit } from './audit3-DMO_fUGp.js';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { readFile, mkdir, appendFile } from 'node:fs/promises';
-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';
-
-//#region ../core/dist/sessions/session-grade.js
-/**
-* Session grading - rubric-based behavioral analysis of agent sessions.
-*
-* Reads audit log entries for a session and applies a 5-dimension rubric
-* to score agent behavior:
-*   - Session discipline (20pts)
-*   - Discovery efficiency (20pts)
-*   - Task hygiene (20pts)
-*   - Error protocol (20pts)
-*   - Progressive disclosure use (20pts)
-*
-* @task T4916
-*/
-/**
-* Grade a session by sessionId using the 5-dimension behavioral rubric.
-*/
-async function gradeSession(sessionId, cwd) {
-	const sessionEntries = await queryAudit({ sessionId });
-	const result = {
-		sessionId,
-		totalScore: 0,
-		maxScore: 100,
-		dimensions: {
-			sessionDiscipline: {
-				score: 0,
-				max: 20,
-				evidence: []
-			},
-			discoveryEfficiency: {
-				score: 0,
-				max: 20,
-				evidence: []
-			},
-			taskHygiene: {
-				score: 0,
-				max: 20,
-				evidence: []
-			},
-			errorProtocol: {
-				score: 0,
-				max: 20,
-				evidence: []
-			},
-			disclosureUse: {
-				score: 0,
-				max: 20,
-				evidence: []
-			}
-		},
-		flags: [],
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		entryCount: sessionEntries.length
-	};
-	if (sessionEntries.length === 0) {
-		result.flags.push("No audit entries found for session (use --grade flag when starting session)");
-		await appendGradeResult(result, cwd);
-		return result;
-	}
-	const sessionListCalls = sessionEntries.filter((e) => e.domain === "session" && e.operation === "list");
-	const sessionEndCalls = sessionEntries.filter((e) => e.domain === "session" && e.operation === "end");
-	const taskOps = sessionEntries.filter((e) => e.domain === "tasks");
-	let disciplineScore = 0;
-	if (sessionListCalls.length > 0) if (new Date(sessionListCalls[0].timestamp).getTime() <= (taskOps.length > 0 ? new Date(taskOps[0].timestamp).getTime() : Infinity)) {
-		disciplineScore += 10;
-		result.dimensions.sessionDiscipline.evidence.push("session.list called before first task op");
-	} else result.flags.push("session.list called after task ops (should check sessions first)");
-	else result.flags.push("session.list never called (check existing sessions before starting)");
-	if (sessionEndCalls.length > 0) {
-		disciplineScore += 10;
-		result.dimensions.sessionDiscipline.evidence.push("session.end called");
-	} else result.flags.push("session.end never called (always end sessions when done)");
-	result.dimensions.sessionDiscipline.score = disciplineScore;
-	const findCalls = sessionEntries.filter((e) => e.domain === "tasks" && e.operation === "find");
-	const listCalls = sessionEntries.filter((e) => e.domain === "tasks" && e.operation === "list");
-	const showCalls = sessionEntries.filter((e) => e.domain === "tasks" && e.operation === "show");
-	let discoveryScore = 0;
-	const totalDiscoveryCalls = findCalls.length + listCalls.length;
-	if (totalDiscoveryCalls > 0) {
-		const findRatio = findCalls.length / totalDiscoveryCalls;
-		if (findRatio >= .8) {
-			discoveryScore += 15;
-			result.dimensions.discoveryEfficiency.evidence.push(`find:list ratio ${(findRatio * 100).toFixed(0)}% >= 80%`);
-		} else {
-			result.flags.push(`tasks.list used ${listCalls.length}x (prefer tasks.find for discovery)`);
-			discoveryScore += Math.round(15 * findRatio);
-		}
-	} else {
-		discoveryScore += 10;
-		result.dimensions.discoveryEfficiency.evidence.push("No discovery calls needed");
-	}
-	if (showCalls.length > 0) {
-		discoveryScore = Math.min(20, discoveryScore + 5);
-		result.dimensions.discoveryEfficiency.evidence.push(`tasks.show used ${showCalls.length}x for detail`);
-	}
-	result.dimensions.discoveryEfficiency.score = Math.min(20, discoveryScore);
-	const addCalls = sessionEntries.filter((e) => e.domain === "tasks" && e.operation === "add" && e.result.success);
-	const existsCalls = sessionEntries.filter((e) => e.domain === "tasks" && e.operation === "exists");
-	const delegate_task_count = sessionEntries.filter((e) => e.operation === "delegate_task" || e.domain === "orchestrate" && e.operation === "spawn" && e.result.success).length;
-	const completedInSession = sessionEntries.filter((e) => e.domain === "tasks" && e.operation === "complete" && e.result.success).length;
-	const isLead = sessionEntries.map((e) => e.metadata?.["role"]).find((r) => typeof r === "string") === "lead";
-	let hygieneScore = 20;
-	for (const addCall of addCalls) {
-		const desc = addCall.params?.description;
-		if (!desc || desc.trim().length === 0) {
-			hygieneScore -= 5;
-			result.flags.push(`tasks.add without description (taskId: ${addCall.metadata?.taskId ?? "unknown"})`);
-		}
-	}
-	const subtaskAdds = addCalls.filter((e) => e.params?.parent);
-	if (subtaskAdds.length > 0 && existsCalls.length > 0) result.dimensions.taskHygiene.evidence.push("Parent existence verified before subtask creation");
-	else if (subtaskAdds.length > 0) {
-		result.flags.push("Subtasks created without tasks.exists parent check");
-		hygieneScore -= 3;
-	}
-	if (addCalls.length > 0 && hygieneScore >= 20) result.dimensions.taskHygiene.evidence.push(`All ${addCalls.length} tasks.add calls had descriptions`);
-	result.dimensions.taskHygiene.evidence.push(`delegate_task_count: ${delegate_task_count}`);
-	if (isLead && delegate_task_count === 0 && completedInSession > 0) {
-		hygieneScore -= 5;
-		result.flags.push(`lead-self-implementation-bypass: session role=lead completed ${completedInSession} task(s) without any delegate_task call — Leads MUST fan out work to Workers (T9217 / ADR-070)`);
-		result.dimensions.taskHygiene.evidence.push("WARNING: lead-self-implementation-bypass detected — no delegate_task calls");
-	} else if (isLead && delegate_task_count > 0) result.dimensions.taskHygiene.evidence.push(`Lead delegation confirmed: ${delegate_task_count} delegate_task call(s)`);
-	result.dimensions.taskHygiene.score = Math.max(0, hygieneScore);
-	const notFoundErrors = sessionEntries.filter((e) => !e.result.success && e.result.exitCode === 4);
-	let errorScore = 20;
-	for (const errEntry of notFoundErrors) {
-		const errIdx = sessionEntries.indexOf(errEntry);
-		if (!sessionEntries.slice(errIdx + 1, errIdx + 5).some((e) => e.domain === "tasks" && (e.operation === "find" || e.operation === "exists"))) {
-			errorScore -= 5;
-			result.flags.push(`E_NOT_FOUND (${errEntry.domain}.${errEntry.operation}) not followed by recovery lookup`);
-		} else result.dimensions.errorProtocol.evidence.push("E_NOT_FOUND followed by recovery lookup");
-	}
-	const duplicateCreates = detectDuplicateCreates(sessionEntries);
-	if (duplicateCreates > 0) {
-		errorScore -= 5;
-		result.flags.push(`${duplicateCreates} potentially duplicate task create(s) detected`);
-	}
-	if (notFoundErrors.length === 0 && duplicateCreates === 0) result.dimensions.errorProtocol.evidence.push("No error protocol violations");
-	result.dimensions.errorProtocol.score = Math.max(0, errorScore);
-	const helpCalls = sessionEntries.filter((e) => e.domain === "admin" && e.operation === "help" || e.domain === "tools" && (e.operation === "skill.show" || e.operation === "skill.list") || e.domain === "skills" && (e.operation === "list" || e.operation === "show"));
-	const queryCalls = sessionEntries.filter((e) => e.metadata?.gateway === "query");
-	let disclosureScore = 0;
-	if (helpCalls.length > 0) {
-		disclosureScore += 10;
-		result.dimensions.disclosureUse.evidence.push(`Progressive disclosure used (${helpCalls.length}x)`);
-	} else result.flags.push("No admin.help or skill lookup calls (load ct-cleo for guidance)");
-	if (queryCalls.length > 0) {
-		disclosureScore += 10;
-		result.dimensions.disclosureUse.evidence.push(`query gateway used ${queryCalls.length}x`);
-	} else result.flags.push("No query gateway calls (use query operations for programmatic access)");
-	result.dimensions.disclosureUse.score = disclosureScore;
-	result.totalScore = Object.values(result.dimensions).reduce((sum, d) => sum + d.score, 0);
-	await feedGradeToBrain(result, cwd);
-	await appendGradeResult(result, cwd);
-	return result;
-}
-/** Detect potentially duplicate task creates (same title within session). */
-function detectDuplicateCreates(entries) {
-	const titles = entries.filter((e) => e.domain === "tasks" && e.operation === "add" && e.result.success).map((e) => e.params?.title?.toLowerCase().trim()).filter(Boolean);
-	const unique = new Set(titles);
-	return titles.length - unique.size;
-}
-/**
-* Feed grade insights back into brain.db as learnings.
-* Best-effort — errors are silently caught.
-*/
-async function feedGradeToBrain(result, projectRoot) {
-	if (!projectRoot) return;
-	try {
-		const { storeLearning } = await import('./learnings-D6Y3YGMU.js');
-		const weakDimensions = [];
-		for (const [name, dim] of Object.entries(result.dimensions)) if (dim.score < dim.max * .5) weakDimensions.push(name);
-		if (weakDimensions.length > 0) await storeLearning(projectRoot, {
-			insight: `Session ${result.sessionId} scored ${result.totalScore}/${result.maxScore}. Weak dimensions: ${weakDimensions.join(", ")}`,
-			source: `grade:${result.sessionId}`,
-			confidence: .8,
-			actionable: true,
-			application: `Improve in next session: ${weakDimensions.join(", ")}`
-		});
-		if (result.flags.length > 0) await storeLearning(projectRoot, {
-			insight: `Session ${result.sessionId} protocol violations: ${result.flags.join("; ")}`,
-			source: `grade:${result.sessionId}`,
-			confidence: .7,
-			actionable: true,
-			application: "Address protocol violations in next session"
-		});
-		if (result.flags.some((f) => f.includes("lead-self-implementation-bypass"))) await storeLearning(projectRoot, {
-			insight: `lead-self-implementation-bypass detected in session ${result.sessionId}: Lead completed tasks without delegate_task. Violates ADR-070 hierarchical orchestration contract.`,
-			source: `grade:${result.sessionId}`,
-			confidence: .9,
-			actionable: true,
-			application: "Next Lead session MUST use delegate_task to fan out work to Workers — no self-implementation."
-		});
-	} catch {}
-}
-/** Append a grade result to .cleo/metrics/GRADES.jsonl */
-async function appendGradeResult(result, cwd) {
-	try {
-		const metricsDir = join(getCleoDirAbsolute(cwd), "metrics");
-		await mkdir(metricsDir, { recursive: true });
-		await appendFile(join(metricsDir, "GRADES.jsonl"), JSON.stringify({
-			...result,
-			evaluator: "auto"
-		}) + "\n", "utf8");
-	} catch {}
-}
-/** Read past grade results from .cleo/metrics/GRADES.jsonl */
-async function readGrades(sessionId, cwd) {
-	try {
-		const gradesPath = join(getCleoDirAbsolute(cwd), "metrics", "GRADES.jsonl");
-		if (!existsSync(gradesPath)) return [];
-		const results = (await readFile(gradesPath, "utf8")).split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
-		return sessionId ? results.filter((r) => r.sessionId === sessionId) : results;
-	} catch {
-		return [];
-	}
-}
-
-export { gradeSession, readGrades };
-//# sourceMappingURL=session-grade-BF4ZZtN_.js.map