@winspan/claude-forge 8.54.3 → 9.2.0

package/dist/daemon/services/kb-injector.js

@@ -0,0 +1,140 @@
+/**
+ * KbInjector — queries the project knowledge base for a prompt and renders
+ * the additionalContext block.
+ *
+ * Extracted from `UserPromptHandler` (D-3 step 3). Single responsibility:
+ *   1. Probe `.forge-knowledge/` presence (cheap).
+ *   2. Run `queryKnowledge` (augmented with optional intent keywords).
+ *   3. Apply score threshold + return `{ block, hits }`.
+ *
+ * Caching: per-(session_id, prompt[:200]) LRU+TTL to dedupe consecutive
+ * Enter re-fires within 5 minutes. Bounded by 500 entries.
+ *
+ * The cache key includes `session_id` so different sessions never collide,
+ * but `kbQueryCache` is intentionally NOT cleared at Stop time — D-1 in the
+ * refactor spec resolved this: the 5-min TTL + 500-entry LRU bound is
+ * sufficient (worst case ~500KB held briefly), and enumerating session-
+ * prefixed keys would require a second index map.
+ */
+// Namespace import (not named) so test code can `vi.spyOn(knowledgeQuery, ...)`
+// and have the service see the stub — named imports bind eagerly under ESM.
+import * as knowledgeQuery from '../../knowledge/query.js';
+import { LRUCache } from '../../core/utils/lru-cache.js';
+import { createHash } from 'node:crypto';
+import { logger } from '../../core/utils/logger.js';
+import { truncateString } from '../../core/utils/format.js';
+import { wrapInjectBlock } from '../utils/inject-block.js';
+export class KbInjector {
+    storage;
+    // ── KB injection (MVP1) ──────────────────────────────────────────────────
+    // Score threshold below which we don't inject. History:
+    //   spec §4.1 estimated 30 → too strict (ASCII prompts maxed at ~30)
+    //   2026-05-22 calibration → 10 (CJK still dead because tokenize 无分词)
+    //   2026-05-22 KPI fix → 5, after CJK n-gram tokenize landed
+    //     (n-gram tokens lower per-hit score; real CJK technical prompt
+    //      "如何修复 daemon socket bug" hits modules/daemon.md @ score 7).
+    // Revisit when feedback-aggregator shows real score distribution.
+    static KB_SCORE_THRESHOLD = 5;
+    /** Cap on KB pages injected per prompt to avoid context bloat. */
+    static KB_MAX_RESULTS = 2;
+    /** Per-page content truncation (chars) — keeps the additionalContext modest. */
+    static KB_CONTENT_TRUNCATE = 800;
+    /** LRU+TTL cache TTL for de-duping Enter re-fires of the same prompt. */
+    static KB_CACHE_TTL_MS = 5 * 60 * 1000;
+    /** Cache capacity (entries). */
+    static KB_CACHE_MAX = 500;
+    kbQueryCache = new LRUCache(KbInjector.KB_CACHE_MAX);
+    constructor(storage = null) {
+        this.storage = storage;
+    }
+    /**
+     * Query the KB and (if any qualifying hits) return a formatted block ready
+     * to push onto `additionalContext`. Always fail-silent — KB failures must
+     * not break the prompt path.
+     *
+     * Returns `null` block when there are zero qualifying hits.
+     */
+    async inject(event, prompt, extraKeywords = []) {
+        const hits = await this.queryKbForPrompt(event.session_id, event.project_path, prompt, extraKeywords);
+        if (hits.length === 0)
+            return { block: null, hits: [] };
+        const block = formatKbBlock(hits, KbInjector.KB_CONTENT_TRUNCATE);
+        return { block, hits };
+    }
+    /**
+     * Query the project knowledge base, returning only hits at or above the
+     * MVP1 score threshold. Always fail-silent — KB failures must not break
+     * the UserPrompt pipeline (resume / convention / skill remain unaffected).
+     *
+     * Cache key is `${session_id}:${sha1(prompt[:200])}` with a 5-minute TTL.
+     * This dedupes consecutive Enter re-fires of the same prompt without
+     * leaking memory across sessions.
+     */
+    async queryKbForPrompt(sessionId, projectPath, prompt, extraKeywords) {
+        try {
+            if (!knowledgeQuery.isKnowledgeBuilt(projectPath))
+                return [];
+            const cacheKey = makeKbCacheKey(sessionId, prompt);
+            const now = Date.now();
+            const cached = this.kbQueryCache.get(cacheKey);
+            if (cached && cached.expiresAt > now) {
+                logger.debug(`[KbInjector] cache hit (${cached.hits.length} hits)`);
+                return cached.hits;
+            }
+            const augmentedQuery = extraKeywords.length > 0
+                ? `${prompt} ${extraKeywords.join(' ')}`
+                : prompt;
+            const result = await knowledgeQuery.queryKnowledge(augmentedQuery, {
+                projectRoot: projectPath,
+                maxResults: KbInjector.KB_MAX_RESULTS,
+                // Skip repo-map symbol hits in the inject path: pages already carry
+                // file:line refs and symbol noise would just lengthen the prompt.
+                includeRepoMap: false,
+                storage: this.storage ?? undefined,
+            });
+            const qualifying = result.pages.filter((h) => h.score >= KbInjector.KB_SCORE_THRESHOLD);
+            this.kbQueryCache.set(cacheKey, {
+                hits: qualifying,
+                expiresAt: now + KbInjector.KB_CACHE_TTL_MS,
+            });
+            return qualifying;
+        }
+        catch (err) {
+            logger.warn(`[KbInjector] KB query failed (silently skipped): ${err}`);
+            return [];
+        }
+    }
+}
+// ── Module-private helpers ──────────────────────────────────────────────────
+/**
+ * Build a stable cache key from `sessionId` + the first 200 chars of `prompt`
+ * (hashed to keep the key small and avoid logging concerns).
+ */
+function makeKbCacheKey(sessionId, prompt) {
+    const hash = createHash('sha1').update(prompt.slice(0, 200)).digest('hex');
+    return `${sessionId}:${hash}`;
+}
+/**
+ * Render KB query hits into the additionalContext block (spec §4.1).
+ * Layout mirrors CLAUDE.md:194-206 — banners, per-page header with score &
+ * matched keywords, truncated content, then a "关键文件" list of refs.
+ */
+function formatKbBlock(hits, contentTruncate) {
+    const sections = hits.map((hit) => {
+        const matched = hit.matched_keywords.slice(0, 5).join(', ');
+        const header = `### ${hit.page.name}（score ${hit.score}${matched ? `, matched: ${matched}` : ''}）`;
+        const body = truncateString(hit.page.content, contentTruncate);
+        const refLines = hit.page.refs.slice(0, 4).map((r) => {
+            const sym = r.symbol ? ` — ${r.symbol}` : '';
+            return `- ${r.file}:${r.lineStart}${sym}`;
+        });
+        const refs = refLines.length > 0 ? `\n关键文件：\n${refLines.join('\n')}` : '';
+        return `${header}\n\n${body}${refs}`;
+    });
+    return wrapInjectBlock({
+        openLine: '━━━ 项目背景（来自 .forge-knowledge/）━━━',
+        // Blank lines on both sides preserve the pre-refactor visual padding.
+        body: `\n${sections.join('\n\n')}\n`,
+    });
+}
+//# sourceMappingURL=kb-injector.js.map

package/dist/daemon/services/kb-injector.js.map

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

package/dist/daemon/services/outcome-classification-service.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 type { StopEvent } from '../../core/types.js';
+import type { SQLiteStorage } from '../../core/storage/sqlite.js';
+import type { TaskSegmenter } from './task-segmenter.js';
+export declare 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).
+     */
+    classifySession(event: StopEvent, storage: SQLiteStorage, taskSegmenter: TaskSegmenter | null): Promise<void>;
+    /**
+     * 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.
+     */
+    classifyIdleTasks(event: StopEvent, storage: SQLiteStorage): Promise<void>;
+    /**
+     * Count a single task's Edit/Write intent events. Best-effort: 0 on error so
+     * classification never throws because of a storage hiccup.
+     */
+    private safeTaskEditIntent;
+    /**
+     * Session-level edit intent = COUNT of Edit/Write events across the session
+     * (tool_name only; gzip-safe). Best-effort, 0 on error.
+     */
+    private safeSessionEditIntent;
+}
+//# sourceMappingURL=outcome-classification-service.d.ts.map

package/dist/daemon/services/outcome-classification-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcome-classification-service.d.ts","sourceRoot":"","sources":["../../../src/daemon/services/outcome-classification-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAczD,qBAAa,4BAA4B;IACvC;;;;;;OAMG;IACG,eAAe,CACnB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,aAAa,EACtB,aAAa,EAAE,aAAa,GAAG,IAAI,GAClC,OAAO,CAAC,IAAI,CAAC;IAwHhB;;;;;;;;OAQG;IACG,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IA8ChF;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;CAQ9B"}

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 './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"}