agentic-qe 3.15.9 → 3.15.11

package/dist/learning/usage-outcome.js

@@ -0,0 +1,84 @@
+/**
+ * Agentic QE v3 - Measured outcomes for pattern usage (#1129)
+ *
+ * `qe_pattern_usage.success` used to mean "the call completed": MCP tool runs
+ * were captured with a fixed `success: true`, hooks pass a hardcoded
+ * `--success`, and session consolidation writes only aggregates whose success
+ * rate already passed a threshold. The aggregate "Pattern Success Rate" was
+ * 100% by construction.
+ *
+ * A usage row counts as a measured outcome only when it says so:
+ * `metrics_json.outcome = 'measured'`, written when success was read from the
+ * result. Today that is a test run: every test passed, or some failed.
+ * Every other row, whatever its age or writer, is unmeasured (tag and exclude,
+ * the #1109 decision): it is kept and counted as a use, never rewritten, and
+ * never part of the rate.
+ *
+ * The rate is per run, not per row: one tool run writes a row for each
+ * pattern involved (the captured experience's pattern plus every routing
+ * hint), all with the same verdict, and they share `metrics_json.runId`.
+ */
+function asRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+/**
+ * Read the outcome of a completed tool run from its result.
+ * Tools without an outcome measure here are `unmeasured`: completing is not
+ * evidence that the result was good.
+ */
+export function measureToolOutcome(taskType, data) {
+    const record = asRecord(data);
+    if (taskType === 'execute-tests') {
+        const total = finiteNumber(record?.total);
+        const failed = finiteNumber(record?.failed);
+        if (total !== null && total > 0 && failed !== null) {
+            return { measured: true, success: failed === 0, basis: 'test-results' };
+        }
+        return { measured: false, success: null, basis: 'no-test-results' };
+    }
+    // index-code is not measured (#1142 review): it fails both for the caller's
+    // input (a missing, empty or outside target) and for indexer errors, and the
+    // result does not tell them apart. Counting only the successful indexes
+    // would make its rate 100% by selection again.
+    return { measured: false, success: null, basis: 'tool-completed' };
+}
+/** Metrics fields that tag a usage row with its outcome provenance and run. */
+export function usageOutcomeMetrics(outcome, runId) {
+    return {
+        outcome: outcome.measured ? 'measured' : 'unmeasured',
+        outcomeBasis: outcome.basis,
+        ...(runId ? { runId } : {}),
+    };
+}
+/** Classify one qe_pattern_usage row (TypeScript twin of MEASURED_USAGE_SQL). */
+export function usageOutcomeOf(metrics) {
+    return metrics?.outcome === 'measured' ? 'measured' : 'unmeasured';
+}
+/**
+ * SQL expression over qe_pattern_usage: 1 for a measured row, 0 otherwise.
+ * Mirrors usageOutcomeOf; json_valid keeps a malformed row from failing the query.
+ */
+export const MEASURED_USAGE_SQL = `(CASE WHEN json_valid(metrics_json) AND json_extract(metrics_json, '$.outcome') = 'measured' THEN 1 ELSE 0 END)`;
+/** SQL expression: the run a usage row belongs to (a row without runId is its own run). */
+export const USAGE_RUN_SQL = `COALESCE(CASE WHEN json_valid(metrics_json) THEN json_extract(metrics_json, '$.runId') END, 'row:' || id)`;
+/**
+ * e.g. "9 (4 measured runs, 0 unmeasured)". A run can write several usage
+ * rows (one per pattern involved), so measured runs can be fewer than rows.
+ */
+export function formatLearningOutcomes(stats) {
+    if (stats.learningOutcomes === 0)
+        return '0';
+    const measured = stats.measuredOutcomes ?? 0;
+    const unmeasured = stats.unmeasuredOutcomes ?? stats.learningOutcomes;
+    return `${stats.learningOutcomes} (${measured} measured runs, ${unmeasured} unmeasured)`;
+}
+/** The rate as a percentage, or why there is none (#1129). */
+export function formatPatternSuccessRate(stats) {
+    return stats.patternSuccessRate === null
+        ? 'insufficient evidence (no measured outcomes)'
+        : `${(stats.patternSuccessRate * 100).toFixed(1)}% of ${stats.measuredOutcomes ?? 0} measured runs`;
+}
+//# sourceMappingURL=usage-outcome.js.map

package/dist/mcp/background-workers.d.ts

@@ -10,6 +10,18 @@
  * stderr writer so stdout stays reserved for JSON-RPC.
  */
 import { type WorkerEnv } from '../workers/worker-env.js';
-export type BackgroundWorkersOutcome = 'disabled' | 'started' | 'failed';
+/**
+ * #1116: `starting` while the worker daemon's first runs continue in the
+ * background; `startBackgroundWorkers` never reports `started` before they
+ * have finished. The settled state is in `getBackgroundWorkersState()`.
+ */
+export type BackgroundWorkersOutcome = 'disabled' | 'starting' | 'failed';
+export interface BackgroundWorkersState {
+    state: 'not-requested' | 'disabled' | 'starting' | 'started' | 'failed';
+    /** Why the start failed, when `state` is `failed`. */
+    error?: string;
+}
+/** Where the worker daemon's start stands now, including a background failure. */
+export declare function getBackgroundWorkersState(): BackgroundWorkersState;
 export declare function startBackgroundWorkers(log: (message: string) => void, env?: WorkerEnv): Promise<BackgroundWorkersOutcome>;
 //# sourceMappingURL=background-workers.d.ts.map

package/dist/mcp/background-workers.js

@@ -10,10 +10,16 @@
  * stderr writer so stdout stays reserved for JSON-RPC.
  */
 import { isWorkersEnabled } from '../workers/worker-env.js';
+let workersState = { state: 'not-requested' };
+/** Where the worker daemon's start stands now, including a background failure. */
+export function getBackgroundWorkersState() {
+    return { ...workersState };
+}
 export async function startBackgroundWorkers(log, env = process.env) {
     if (!isWorkersEnabled(env)) {
         log(`[MCP] Background workers disabled (AQE_WORKERS_ENABLED=${env.AQE_WORKERS_ENABLED}); ` +
             'worker daemon and quality daemon not started\n');
+        workersState = { state: 'disabled' };
         return 'disabled';
     }
     // In database-free mode the workers run against the in-memory unified
@@ -31,11 +37,18 @@ export async function startBackgroundWorkers(log, env = process.env) {
         // #1066: start() runs every worker's first tick one after another, which
         // can take minutes. Let it finish in the background so the QualityDaemon
         // (and the HTTP server after us) do not wait for it.
-        void daemon.start().catch((startError) => {
+        // #1116: report `starting` now and the real outcome when it settles, so a
+        // start that fails in the background is never reported as started.
+        workersState = { state: 'starting' };
+        void daemon.start().then(() => {
+            workersState = { state: 'started' };
+            log('[MCP] Background workers started (first runs complete)\n');
+        }, (startError) => {
+            workersState = { state: 'failed', error: String(startError) };
             log(`[MCP] WARNING: Background workers failed to start: ${startError}\n`);
         });
         const status = daemon.getStatus();
-        log(`[MCP] Background workers started (${status.workerManager.totalWorkers} workers; ` +
+        log(`[MCP] Background workers starting (${status.workerManager.totalWorkers} workers; ` +
             'first runs continue in the background)\n');
         // IMP-10: Start QualityDaemon with persistent memory (Finding 1 & 2 resolution)
         try {
@@ -66,9 +79,10 @@ export async function startBackgroundWorkers(log, env = process.env) {
             log(`[MCP] WARNING: Quality daemon failed to start: ${qdError}\n`);
             // Non-fatal — MCP continues without quality daemon
         }
-        return 'started';
+        return 'starting';
     }
     catch (daemonError) {
+        workersState = { state: 'failed', error: String(daemonError) };
         log(`[MCP] WARNING: Background workers failed to start: ${daemonError}\n`);
         // Non-fatal — MCP server continues without background workers
         return 'failed';