@winspan/claude-forge 8.54.4 → 9.12.0

package/dist/daemon/services/outcome-classification-service.js

@@ -0,0 +1,214 @@
+/**
+ * OutcomeClassificationService — Stop-time outcome instrumentation.
+ *
+ * Extracted from `StopHandler` (D-3) so the orchestrator stays thin.
+ * Single responsibility: gather signals + run `classifyOutcome` + persist
+ * outcome columns on `sessions` + `tasks`, plus the Phase 2 metrics rollup
+ * back-fill.
+ *
+ * Lifecycle: owned by `StopHandler` (constructed per-daemon, called per-event).
+ * Stateless — no per-call construction deps; each method receives storage +
+ * taskSegmenter explicitly so the service is trivially injectable in tests.
+ *
+ * Failure mode: every public method is fire-and-forget. Never throws; logs at
+ * debug level when storage / git subprocess hiccups.
+ */
+import { logger } from '../../core/utils/logger.js';
+import { formatError } from '../../core/utils/format.js';
+import { truncateSessionId } from '../../core/utils/session.js';
+import { collectViolations } from '../../core/insights/violation-reporter.js';
+import { classifyOutcome, collectCommitStats, } from './outcome-classifier.js';
+/** Upper bound on idle tasks backfilled per Stop (mirrors original). */
+const MAX_IDLE_TASKS_PER_RUN = 20;
+export class OutcomeClassificationService {
+    /**
+     * Classify the session's outcome at Stop time and persist to both
+     * `sessions` and the most recent task row. Also rolls up Phase 2 metrics
+     * (intercept_count / kb_inject_count / skill_match_count).
+     *
+     * Fire-and-forget; never throws (debug-logs on error).
+     */
+    async classifySession(event, storage, taskSegmenter) {
+        try {
+            const session = storage.getSession(event.session_id);
+            if (!session) {
+                logger.debug(`[OutcomeClassification] skipped: session ${truncateSessionId(event.session_id)} not in aggregate`);
+                return;
+            }
+            const startIso = session.start_time;
+            const endIso = event.timestamp;
+            // Violations are collected ONLY for the persisted user_violation_count
+            // column (dashboard surfacing) — they NEVER influence the outcome verdict
+            // (governance interceptions inflate them). Best-effort.
+            let violationCount = 0;
+            try {
+                violationCount = collectViolations(storage, {
+                    sessionId: event.session_id,
+                    days: 365,
+                    limit: 1000,
+                }).length;
+            }
+            catch (err) {
+                logger.debug(`[OutcomeClassification] violation collect failed: ${formatError(err)}`);
+            }
+            // Informational only: session-level git commit count (NOT load-bearing —
+            // see outcome-classifier v2). Surfaced in the reason / persisted column.
+            const commitStats = await collectCommitStats(event.project_path, startIso, endIso);
+            // PRIMARY signal: session-level edit intent (Edit/Write count via
+            // tool_name; gzip-safe). Drives success vs answered.
+            const sessionEditIntent = this.safeSessionEditIntent(storage, event.session_id);
+            const input = {
+                session_id: event.session_id,
+                start_time: startIso,
+                end_time: endIso,
+                event_count: session.event_count,
+                edit_intent_count: sessionEditIntent,
+                commit_count: commitStats.commit_count,
+                reverted_commits: commitStats.reverted_commits,
+            };
+            const result = classifyOutcome(input);
+            const classifiedAt = new Date().toISOString();
+            storage.updateSessionOutcome(event.session_id, {
+                outcome: result.outcome,
+                outcome_reason: result.reason,
+                commit_count: commitStats.commit_count,
+                reverted_commits: commitStats.reverted_commits,
+                user_violation_count: violationCount,
+                classified_at: classifiedAt,
+            });
+            // Stamp the CURRENT task with its OWN edit-intent signal (from
+            // task_events — includes sub-agent edits). This is the fix for "活跃 task
+            // 套 session result": a 干活 task is classified on whether IT changed
+            // code, independent of the session-level verdict.
+            const currentTaskId = taskSegmenter?.getCurrentTaskId(event.session_id) ?? null;
+            if (currentTaskId) {
+                try {
+                    const taskEditIntent = this.safeTaskEditIntent(storage, currentTaskId);
+                    const taskInput = {
+                        session_id: event.session_id,
+                        start_time: startIso,
+                        end_time: endIso,
+                        event_count: session.event_count,
+                        edit_intent_count: taskEditIntent,
+                        commit_count: commitStats.commit_count,
+                    };
+                    const taskResult = classifyOutcome(taskInput);
+                    storage.updateTask(currentTaskId, {
+                        outcome: taskResult.outcome,
+                        outcome_reason: taskResult.reason,
+                        user_violation_count: violationCount,
+                        classified_at: classifiedAt,
+                    });
+                }
+                catch (err) {
+                    logger.debug(`[OutcomeClassification] task update failed: ${formatError(err)}`);
+                }
+            }
+            logger.info(`[OutcomeClassification] ${truncateSessionId(event.session_id)}: ` +
+                `${result.outcome} (${result.reason}) — ` +
+                `events=${session.event_count} edit_intent=${sessionEditIntent} ` +
+                `commits=${commitStats.commit_count}`);
+            // Phase 2 metrics rollup (master roadmap §2): aggregate row counts from
+            // the three Phase 0/1/MVP1 fact tables and back-fill sessions.* so the
+            // dashboard / weekly-report can SELECT directly instead of JOINing on
+            // every read. Pure analytics — always on, no feature flag.
+            try {
+                const interceptCount = storage.countToolInterceptsBySession(event.session_id);
+                const kbInjectCount = storage.countInjectionsBySessionByHandler(event.session_id, 'UserPromptSubmitHandler:kb');
+                const skillMatchCount = storage.countSkillInvocationsBySession(event.session_id);
+                storage.updateSessionMetrics(event.session_id, {
+                    interceptCount,
+                    kbInjectCount,
+                    skillMatchCount,
+                });
+                logger.info(`[OutcomeClassification] Session metrics: ` +
+                    `intercept=${interceptCount} kb=${kbInjectCount} skill=${skillMatchCount}`);
+            }
+            catch (err) {
+                logger.debug(`[OutcomeClassification] metrics rollup failed: ${formatError(err)}`);
+            }
+        }
+        catch (err) {
+            logger.debug(`[OutcomeClassification] failed: ${formatError(err)}`);
+        }
+    }
+    /**
+     * Backfill outcome on all unclassified completed/abandoned tasks for the
+     * session. Without this, TaskSegmenter-completed tasks (the ones closed by a
+     * new-prompt switch) stay outcome=NULL forever.
+     *
+     * spec 1100 v2: classification is pure edit-intent — NO git subprocess per
+     * task. Gated to MAX_IDLE_TASKS_PER_RUN to bound the per-task edit-intent
+     * queries. Fire-and-forget; never throws.
+     */
+    async classifyIdleTasks(event, storage) {
+        try {
+            const idle = storage.queryIdleUnclassifiedTasks(event.session_id);
+            if (idle.length === 0)
+                return;
+            const slice = idle.slice(0, MAX_IDLE_TASKS_PER_RUN);
+            const classifiedAt = new Date().toISOString();
+            let updated = 0;
+            for (const t of slice) {
+                try {
+                    const startIso = t.start_time;
+                    const endIso = t.end_time ?? event.timestamp;
+                    // PRIMARY signal: per-task edit intent (task_events; gzip-safe).
+                    const editIntent = this.safeTaskEditIntent(storage, t.id);
+                    const input = {
+                        session_id: event.session_id,
+                        start_time: startIso,
+                        end_time: endIso,
+                        event_count: t.event_count ?? 0,
+                        edit_intent_count: editIntent,
+                    };
+                    const result = classifyOutcome(input);
+                    storage.updateTask(t.id, {
+                        outcome: result.outcome,
+                        outcome_reason: result.reason,
+                        classified_at: classifiedAt,
+                    });
+                    updated += 1;
+                }
+                catch (err) {
+                    logger.debug(`[OutcomeClassification] idle task classify failed for ${t.id}: ${formatError(err)}`);
+                }
+            }
+            if (updated > 0) {
+                logger.info(`[OutcomeClassification] Backfilled outcome for ${updated}/${idle.length} idle task(s) ` +
+                    `on session ${truncateSessionId(event.session_id)}`);
+            }
+        }
+        catch (err) {
+            logger.debug(`[OutcomeClassification] idle task classification failed: ${formatError(err)}`);
+        }
+    }
+    // ── edit-intent helpers (spec 1100 v2) ────────────────────────────────
+    /**
+     * Count a single task's Edit/Write intent events. Best-effort: 0 on error so
+     * classification never throws because of a storage hiccup.
+     */
+    safeTaskEditIntent(storage, taskId) {
+        try {
+            return storage.countEditIntentEventsByTask(taskId);
+        }
+        catch (err) {
+            logger.debug(`[OutcomeClassification] edit-intent count failed for ${taskId}: ${formatError(err)}`);
+            return 0;
+        }
+    }
+    /**
+     * Session-level edit intent = COUNT of Edit/Write events across the session
+     * (tool_name only; gzip-safe). Best-effort, 0 on error.
+     */
+    safeSessionEditIntent(storage, sessionId) {
+        try {
+            return storage.countEditIntentEventsBySession(sessionId);
+        }
+        catch (err) {
+            logger.debug(`[OutcomeClassification] session edit-intent failed for ${sessionId}: ${formatError(err)}`);
+            return 0;
+        }
+    }
+}
+//# sourceMappingURL=outcome-classification-service.js.map

package/dist/daemon/services/outcome-classification-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-classification-service.js","sourceRoot":"","sources":["../../../src/daemon/services/outcome-classification-service.ts"],"names":[],"mappings":"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"}

package/dist/daemon/services/outcome-classifier.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Outcome classifier (spec 1100 v2 — edit-intent-driven, 2026-06-02)
+ *
+ * Pure-function module that assigns one of
+ * `success | answered | abandoned (| partial)` to a session (or task) based on
+ * a tiny set of robust signals collected at Stop time.
+ *
+ * ## Why this rewrite
+ * The previous version keyed `success` off git `commit_count` attributed by a
+ * time window, then a v1.5 attempted to fix it with file→task commit
+ * attribution. A dry-run proved the attribution path is **broken**: `tool_input`
+ * (which holds `file_path`) is gzip-compressed, so file attribution silently
+ * fails → 0 commits attributed → genuine work judged failed AND ~105 real
+ * successes downgraded. We therefore **delete all commit attribution** and key
+ * the verdict off a signal that cannot be corrupted by gzip:
+ *
+ *   `edit_intent_count` = COUNT(events WHERE tool_name IN
+ *   ('Edit','Write','MultiEdit','NotebookEdit')) on the task's task_events.
+ *   Only the `tool_name` column is read — never the compressed `tool_input` —
+ *   so it is always correct. Sub-agent Edit/Write events are already linked to
+ *   the parent task's task_events, so "did this task change code?" is captured.
+ *
+ * ## Design principles
+ *   - **No LLM, no I/O**: classify is referentially transparent; signal
+ *     gathering (edit-intent count) lives in the caller.
+ *   - **Edit-intent is the primary signal**; `commit_count` is informational
+ *     only and NOT load-bearing for the verdict.
+ *   - **No violation-based downgrade**: daemon governance interceptions inflate
+ *     `violation_count`, so it must not influence outcome.
+ *   - **Tunable**: thresholds are exported constants.
+ *
+ * ## Priority chain (first matching branch wins)
+ *   1. abandoned/no_work    — event_count <= 1
+ *   2. abandoned/too_short  — duration < 30s && event_count < 5
+ *   3. answered/no-change-expected — edit_intent == 0 (pure Q&A / research)
+ *   4. success/did-work     — edit_intent > 0
+ *
+ * The `partial` outcome is retained as a defensive fallback only (the chain
+ * above is total over valid inputs, so it is effectively unreachable).
+ */
+/**
+ * Thresholds (exported for visibility in tests and for back-test tuning).
+ * Spec defaults — DO NOT casually mutate; the spec contains rationale.
+ */
+export declare const OUTCOME_THRESHOLDS: {
+    /** Below this duration with few events → `abandoned/too_short`. */
+    readonly MIN_DURATION_FOR_ABANDONED_SEC: 30;
+    /** Below this event count combined with short duration → `abandoned/too_short`. */
+    readonly MIN_EVENT_FOR_ABANDONED: 5;
+    /** At or below this event count → `abandoned/no_work` (regardless of duration). */
+    readonly ABSOLUTE_NO_WORK_EVENT_CAP: 1;
+};
+/**
+ * Edit-intent threshold. A task with at least this many Edit/Write intents is
+ * treated as "code work was done" → `success`; below it (i.e. 0) the task is a
+ * pure Q&A / research task → `answered/no-change-expected`.
+ *
+ * Kept as a named constant (not a magic literal) so the answered-vs-success
+ * split can be retuned in one place. Currently 1 = "any edit counts".
+ */
+export declare const EDIT_INTENT_THRESHOLD_FOR_WORK = 1;
+export interface OutcomeInput {
+    /** Only used in `reason` strings; not load-bearing. */
+    session_id?: string;
+    /** ISO 8601 timestamp (parsed via Date.parse). */
+    start_time: string;
+    /** ISO 8601 timestamp (parsed via Date.parse). */
+    end_time: string;
+    /** Total events on this session (or task window). */
+    event_count: number;
+    /**
+     * Number of Edit/Write/MultiEdit/NotebookEdit events on this task (via
+     * task_events join). THE primary signal: >0 → success, ==0 → answered.
+     * Optional + defaults to 0 so legacy callers / unit tests stay green.
+     */
+    edit_intent_count?: number;
+    /**
+     * Informational only — NOT used by the verdict. Kept so callers can pass it
+     * through to persistence (sessions/tasks.commit_count column) and so the
+     * `reason` string can optionally surface a session-level commit count.
+     */
+    commit_count?: number;
+    /**
+     * Informational only — NOT used by the verdict. Retained for the persisted
+     * `reverted_commits` column; the previous per-task git revert signal was
+     * removed (it required per-task git subprocesses we deleted).
+     */
+    reverted_commits?: number;
+    /**
+     * Informational only — NOT used by the verdict. Daemon governance
+     * interceptions inflate this, so it must never downgrade an outcome.
+     */
+    violation_count?: number;
+}
+export interface OutcomeResult {
+    /**
+     * `answered` is a first-class outcome for pure Q&A / research tasks that
+     * legitimately produced no code change. `failed` / `partial` are retained in
+     * the union for back-compat with persisted historical rows and the defensive
+     * fallback, but the v2 chain only emits `success | answered | abandoned`.
+     * The schema `outcome` CHECK was relaxed to a non-empty-string guard so these
+     * values persist without a per-value table rebuild.
+     */
+    outcome: 'success' | 'partial' | 'failed' | 'abandoned' | 'answered';
+    /** Short, machine-stable text describing which rule fired. */
+    reason: string;
+}
+/**
+ * Classify an outcome from aggregated signals. Pure function; no I/O.
+ *
+ * Decision tree (spec 1100 v2 — edit-intent-driven):
+ *   1. event_count <= 1                      → abandoned/no_work
+ *   2. duration < 30s && event_count < 5     → abandoned/too_short
+ *   3. edit_intent == 0                      → answered/no-change-expected
+ *   4. edit_intent > 0                       → success/did-work
+ *   (fallback: partial — effectively unreachable, defensive only)
+ *
+ * `null` / undefined / NaN inputs are coerced defensively (missing counts → 0,
+ * missing timestamps → durationSec = 0) so callers can pass partial data
+ * without blowing up.
+ */
+export declare function classifyOutcome(input: OutcomeInput): OutcomeResult;
+export interface CommitStats {
+    commit_count: number;
+    reverted_commits: number;
+}
+/**
+ * Gather git commit stats for the time window `[startIso, endIso]` at
+ * `projectPath`. Returns `{ commit_count: 0, reverted_commits: 0 }` for any
+ * failure (non-git directory, missing path, git not installed, timeout, etc.) —
+ * outcome classifier handles "no signal" as the non-git fallback.
+ *
+ * Timeout: 5s total (per spec §2.5 prior art).
+ */
+export declare function collectCommitStats(projectPath: string | null | undefined, startIso: string, endIso: string): Promise<CommitStats>;
+//# sourceMappingURL=outcome-classifier.d.ts.map

package/dist/daemon/services/outcome-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-classifier.d.ts","sourceRoot":"","sources":["../../../src/daemon/services/outcome-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,mEAAmE;;IAEnE,mFAAmF;;IAEnF,mFAAmF;;CAE3E,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;IACrE,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa,CAuClE;AAqBD,MAAM,WAAW,WAAW;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACtC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,CAAC,CAmCtB"}

package/dist/daemon/services/outcome-classifier.js

@@ -0,0 +1,178 @@
+/**
+ * Outcome classifier (spec 1100 v2 — edit-intent-driven, 2026-06-02)
+ *
+ * Pure-function module that assigns one of
+ * `success | answered | abandoned (| partial)` to a session (or task) based on
+ * a tiny set of robust signals collected at Stop time.
+ *
+ * ## Why this rewrite
+ * The previous version keyed `success` off git `commit_count` attributed by a
+ * time window, then a v1.5 attempted to fix it with file→task commit
+ * attribution. A dry-run proved the attribution path is **broken**: `tool_input`
+ * (which holds `file_path`) is gzip-compressed, so file attribution silently
+ * fails → 0 commits attributed → genuine work judged failed AND ~105 real
+ * successes downgraded. We therefore **delete all commit attribution** and key
+ * the verdict off a signal that cannot be corrupted by gzip:
+ *
+ *   `edit_intent_count` = COUNT(events WHERE tool_name IN
+ *   ('Edit','Write','MultiEdit','NotebookEdit')) on the task's task_events.
+ *   Only the `tool_name` column is read — never the compressed `tool_input` —
+ *   so it is always correct. Sub-agent Edit/Write events are already linked to
+ *   the parent task's task_events, so "did this task change code?" is captured.
+ *
+ * ## Design principles
+ *   - **No LLM, no I/O**: classify is referentially transparent; signal
+ *     gathering (edit-intent count) lives in the caller.
+ *   - **Edit-intent is the primary signal**; `commit_count` is informational
+ *     only and NOT load-bearing for the verdict.
+ *   - **No violation-based downgrade**: daemon governance interceptions inflate
+ *     `violation_count`, so it must not influence outcome.
+ *   - **Tunable**: thresholds are exported constants.
+ *
+ * ## Priority chain (first matching branch wins)
+ *   1. abandoned/no_work    — event_count <= 1
+ *   2. abandoned/too_short  — duration < 30s && event_count < 5
+ *   3. answered/no-change-expected — edit_intent == 0 (pure Q&A / research)
+ *   4. success/did-work     — edit_intent > 0
+ *
+ * The `partial` outcome is retained as a defensive fallback only (the chain
+ * above is total over valid inputs, so it is effectively unreachable).
+ */
+/**
+ * Thresholds (exported for visibility in tests and for back-test tuning).
+ * Spec defaults — DO NOT casually mutate; the spec contains rationale.
+ */
+export const OUTCOME_THRESHOLDS = {
+    /** Below this duration with few events → `abandoned/too_short`. */
+    MIN_DURATION_FOR_ABANDONED_SEC: 30,
+    /** Below this event count combined with short duration → `abandoned/too_short`. */
+    MIN_EVENT_FOR_ABANDONED: 5,
+    /** At or below this event count → `abandoned/no_work` (regardless of duration). */
+    ABSOLUTE_NO_WORK_EVENT_CAP: 1,
+};
+/**
+ * Edit-intent threshold. A task with at least this many Edit/Write intents is
+ * treated as "code work was done" → `success`; below it (i.e. 0) the task is a
+ * pure Q&A / research task → `answered/no-change-expected`.
+ *
+ * Kept as a named constant (not a magic literal) so the answered-vs-success
+ * split can be retuned in one place. Currently 1 = "any edit counts".
+ */
+export const EDIT_INTENT_THRESHOLD_FOR_WORK = 1;
+/**
+ * Classify an outcome from aggregated signals. Pure function; no I/O.
+ *
+ * Decision tree (spec 1100 v2 — edit-intent-driven):
+ *   1. event_count <= 1                      → abandoned/no_work
+ *   2. duration < 30s && event_count < 5     → abandoned/too_short
+ *   3. edit_intent == 0                      → answered/no-change-expected
+ *   4. edit_intent > 0                       → success/did-work
+ *   (fallback: partial — effectively unreachable, defensive only)
+ *
+ * `null` / undefined / NaN inputs are coerced defensively (missing counts → 0,
+ * missing timestamps → durationSec = 0) so callers can pass partial data
+ * without blowing up.
+ */
+export function classifyOutcome(input) {
+    const startMs = parseTs(input.start_time);
+    const endMs = parseTs(input.end_time);
+    const durationSec = startMs !== null && endMs !== null && endMs >= startMs
+        ? (endMs - startMs) / 1000
+        : 0;
+    const eventCount = nonNegInt(input.event_count);
+    // Primary signal: >0 means code was changed (Edit/Write/MultiEdit/Notebook),
+    // ==0 means a pure Q&A / research task. Reads only tool_name → gzip-safe.
+    const editIntent = nonNegInt(input.edit_intent_count);
+    const hasEditIntent = editIntent >= EDIT_INTENT_THRESHOLD_FOR_WORK;
+    // ── 1. abandoned ────────────────────────────────────────────────────────
+    if (eventCount <= OUTCOME_THRESHOLDS.ABSOLUTE_NO_WORK_EVENT_CAP) {
+        return { outcome: 'abandoned', reason: 'no_work' };
+    }
+    if (durationSec < OUTCOME_THRESHOLDS.MIN_DURATION_FOR_ABANDONED_SEC &&
+        eventCount < OUTCOME_THRESHOLDS.MIN_EVENT_FOR_ABANDONED) {
+        return { outcome: 'abandoned', reason: 'too_short' };
+    }
+    // ── 2. answered (pure Q&A / research — no change expected) ───────────────
+    // No edit intent → the task did exactly what was asked (answer / investigate)
+    // and legitimately produced no code change. NOT a failure.
+    if (!hasEditIntent) {
+        return { outcome: 'answered', reason: 'no-change-expected' };
+    }
+    // ── 3. success (code was changed) ────────────────────────────────────────
+    // edit_intent > 0 → the task (incl. sub-agents whose Edit/Write events are
+    // linked to this task) changed code. commit_count is surfaced in the reason
+    // for context but does NOT gate the verdict.
+    const commits = nonNegInt(input.commit_count);
+    const reason = commits > 0 ? `did-work+commit=${commits}` : 'did-work';
+    return { outcome: 'success', reason };
+}
+// ── Git signal gathering (informational only) ──────────────────────────────
+//
+// spec 1100 v2: the verdict no longer depends on git. `collectCommitStats` is
+// kept ONLY as an informational session-level signal (other callers —
+// backfill-outcomes.ts, idle-session-sweeper — still import it) so the success
+// `reason` can optionally surface a commit count. The previous per-task
+// file→commit attribution (`attributeCommitsToTasks`) was DELETED: it relied on
+// decoding gzip `tool_input` for file paths, which silently failed and
+// corrupted the verdict (0 commits attributed → real work judged failed).
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { existsSync } from 'node:fs';
+const execFileAsync = promisify(execFile);
+/** Subjects matching these patterns count as "reverted_commits" (case-insensitive). */
+const REVERT_KEYWORDS_REGEX = /^(revert|hotfix|amend|fix\s+typo)/i;
+/**
+ * Gather git commit stats for the time window `[startIso, endIso]` at
+ * `projectPath`. Returns `{ commit_count: 0, reverted_commits: 0 }` for any
+ * failure (non-git directory, missing path, git not installed, timeout, etc.) —
+ * outcome classifier handles "no signal" as the non-git fallback.
+ *
+ * Timeout: 5s total (per spec §2.5 prior art).
+ */
+export async function collectCommitStats(projectPath, startIso, endIso) {
+    if (!projectPath || !existsSync(projectPath)) {
+        return { commit_count: 0, reverted_commits: 0 };
+    }
+    const opts = { cwd: projectPath, timeout: 5000 };
+    try {
+        // Confirm a git work-tree at projectPath; cheaper than letting `log` fail.
+        await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], opts);
+    }
+    catch {
+        return { commit_count: 0, reverted_commits: 0 };
+    }
+    try {
+        // `--all` so commits on non-HEAD branches still count (rare for our case
+        // but cheap to include). `%s` outputs subject only.
+        const { stdout } = await execFileAsync('git', [
+            'log',
+            '--all',
+            '--since', startIso,
+            '--until', endIso,
+            '--pretty=format:%s',
+        ], opts);
+        const lines = stdout
+            .toString()
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0);
+        const reverted = lines.filter((subj) => REVERT_KEYWORDS_REGEX.test(subj)).length;
+        return { commit_count: lines.length, reverted_commits: reverted };
+    }
+    catch {
+        return { commit_count: 0, reverted_commits: 0 };
+    }
+}
+// ── Helpers ───────────────────────────────────────────────────────────────
+function parseTs(s) {
+    if (typeof s !== 'string' || s.length === 0)
+        return null;
+    const t = Date.parse(s);
+    return Number.isFinite(t) ? t : null;
+}
+function nonNegInt(v) {
+    if (typeof v !== 'number' || !Number.isFinite(v) || v < 0)
+        return 0;
+    return Math.floor(v);
+}
+//# sourceMappingURL=outcome-classifier.js.map

package/dist/daemon/services/outcome-classifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-classifier.js","sourceRoot":"","sources":["../../../src/daemon/services/outcome-classifier.ts"],"names":[],"mappings":"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"}

package/dist/daemon/services/outcome-nudge.d.ts

@@ -0,0 +1,107 @@
+/**
+ * OutcomeNudge — outcome-backfill soft-gate (decision 1ac6fc31, 2026-06-04).
+ *
+ * Closes the last gap in the harness learning loop: of ~12 resolved decisions,
+ * only 3 had their `outcome` back-filled (75% miss), so decision-maker's
+ * Step 1.5 precedent weighting ran empty. CLAUDE.md already mandates the
+ * implementing agent back-fill via `cf decisions outcome <id> --result ...`,
+ * but the document constraint alone failed.
+ *
+ * This is a PURE SOFT-GATE. It ONLY emits a `[OUTCOME NUDGE]` systemMessage
+ * reminding the human/agent to run `cf decisions outcome`. It NEVER:
+ *   - writes / infers an outcome value (precedent f4614f7f deleted auto-
+ *     attribution twice — this gate produces text only, never touches
+ *     writeDecisionOutcome),
+ *   - denies / blocks any tool (no `allow:false`, no PreToolUse rule).
+ *
+ * Two delivery paths, both surfacing at UserPromptSubmit (the only hook whose
+ * systemMessage Claude Code actually consumes — see OQ1 below):
+ *
+ *   Option A (threshold, primary backstop): when a session/project has
+ *   accumulated >= N (`outcome_nudge_threshold`, default 2) resolved-but-
+ *   unfilled decisions, inject the nudge on the next UserPromptSubmit, subject
+ *   to cooldown.
+ *
+ *   Option B (completion nudge, DEGRADED): the Stop hook is the natural "just
+ *   finished" moment, but OQ1 found that `stop.sh` only parses `allow`/`reason`
+ *   from the daemon response — it never echoes systemMessage back to Claude
+ *   Code. So Option B cannot deliver text at Stop. Degraded path: StopHandler
+ *   calls `markStopPending()` to set an in-memory per-session flag; the next
+ *   UserPromptSubmit consumes it and injects the nudge regardless of the
+ *   threshold (completion timing is high-signal). The flag is transient (lost
+ *   on daemon restart) — acceptable because Option A's threshold still catches
+ *   the same backlog on the next prompt.
+ *
+ * Cooldown (anti-nag): per-session in-memory timestamp + the global
+ * `outcome_nudge_cooldown_seconds` (default 86400 = 24h). Within the cooldown
+ * window we do not re-nudge the same session. The cooldown is NOT applied to
+ * the degraded Option B path's first fire after a Stop — completion is the
+ * moment we most want the reminder — but it IS recorded so a follow-up prompt
+ * seconds later doesn't double-nudge.
+ *
+ * Fail-safe: every public method catches and degrades to "no nudge". The soft-
+ * gate must never break the prompt pipeline.
+ */
+import type { SQLiteStorage } from '../../core/storage/sqlite.js';
+/** forge_config key for the resolved-unfilled threshold (Option A). */
+export declare const OUTCOME_NUDGE_THRESHOLD_KEY = "outcome_nudge_threshold";
+/** Default Option A threshold — nudge once 2 decisions are awaiting back-fill. */
+export declare const DEFAULT_OUTCOME_NUDGE_THRESHOLD = 2;
+/** forge_config key for the per-session cooldown (seconds). */
+export declare const OUTCOME_NUDGE_COOLDOWN_KEY = "outcome_nudge_cooldown_seconds";
+/** Default cooldown — 24h between nudges for the same session. */
+export declare const DEFAULT_OUTCOME_NUDGE_COOLDOWN_SECONDS = 86400;
+/**
+ * Resolve the Option A threshold from forge_config, falling back to the
+ * default for missing / non-finite / < 1 values.
+ */
+export declare function resolveOutcomeNudgeThreshold(storage?: SQLiteStorage | null): number;
+/**
+ * Resolve the cooldown (seconds) from forge_config. Values <= 0 or above the
+ * hard bound fall back to the default.
+ */
+export declare function resolveOutcomeNudgeCooldownSeconds(storage?: SQLiteStorage | null): number;
+/**
+ * Format the `[OUTCOME NUDGE]` systemMessage. Independent `[OUTCOME NUDGE]`
+ * prefix (parallel to `[DECISION HINT]`) so the two never visually merge when
+ * both appear in the same systemMessage (OQ4). Pure / exported for tests.
+ *
+ * `reason` distinguishes the trigger purely for the leading line; the body
+ * (id list + command) is identical either way.
+ */
+export declare function formatOutcomeNudge(ids: string[], reason: 'completion' | 'threshold'): string;
+/**
+ * OutcomeNudgeService — owns the cooldown / Stop-pending state and computes the
+ * nudge message. One instance lives on UserPromptHandler; StopHandler reaches
+ * it through the existing userPromptHandler reference to set the Stop flag.
+ */
+export declare class OutcomeNudgeService {
+    private readonly state;
+    private key;
+    /**
+     * Degraded Option B entry point. Called by StopHandler at completion. Sets an
+     * in-memory flag iff the session/project has resolved-unfilled decisions, so
+     * the NEXT UserPromptSubmit injects the nudge regardless of the threshold.
+     *
+     * Pure read of storage + flag set; NEVER writes an outcome. Fail-silent.
+     */
+    markStopPending(sessionId: string, projectPath: string, storage: SQLiteStorage | null): void;
+    /**
+     * UserPromptSubmit entry point. Returns the `[OUTCOME NUDGE]` message to
+     * append to systemMessage, or null when no nudge is warranted.
+     *
+     * Fires when EITHER:
+     *   - the Stop-pending flag is set (degraded Option B, completion timing), OR
+     *   - resolved-unfilled count >= threshold (Option A backstop)
+     * AND the per-session cooldown has elapsed.
+     *
+     * Side effects: clears the Stop-pending flag (consumed once) and records the
+     * nudge timestamp for cooldown. NEVER writes an outcome. Fail-silent → null.
+     */
+    evaluate(sessionId: string, projectPath: string, storage: SQLiteStorage | null, nowMs?: number): string | null;
+    /** Clear per-session state. Called by StopHandler.clearSession path is NOT
+     * used (we need the flag to survive into the next prompt); exposed for tests
+     * and for symmetry with other per-session caches. */
+    clearSession(sessionId: string, projectPath: string): void;
+}
+//# sourceMappingURL=outcome-nudge.d.ts.map