agent-nuvira 3.1.3 → 3.3.0

package/dist/learning/unattended-progress.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Measured progress for an unattended job (enterprise-grade hardening, G11).
+ *
+ * WHY THIS IS ITS OWN MODULE. The runner's central guarantee is that progress
+ * is MEASURED, not claimed: a batch that reports success but did not move the
+ * deliverable is a stall, and three stalls stop the run and ask. That rule is
+ * only as good as the measurement, so the measurement lives in one place,
+ * reading artifacts off disk — and every surface (CLI, dashboard, gateway)
+ * measures the same way instead of each inventing its own idea of "done".
+ *
+ * The two inputs:
+ *   1. the long-form ledger — how much of the CONTENT exists (words, units);
+ *   2. the job's `expectedArtifacts` — the files the deliverable promises
+ *      (site, chapter index, optional tools). For a composite ask this is what
+ *      stops "the prose phase finished" being reported as "the deliverable is
+ *      done" while the site is still missing.
+ */
+import { type BatchOutcome, type UnattendedJob, type UnattendedSurface } from './unattended-job.js';
+/**
+ * Weight of the content phase in a composite deliverable's percentage.
+ *
+ * The content IS the deliverable, so it dominates; the surrounding artifacts
+ * are the remaining third. Weighting them any lower would let a beautiful
+ * empty shell sit at 99% after one chapter.
+ */
+export declare const CONTENT_WEIGHT = 0.7;
+/**
+ * How many expected artifacts exist on disk (relative paths resolved against
+ * the project root).
+ *
+ * Split out from the job-shaped wrapper because the orchestrator asks the same
+ * question at planning time — "has this deliverable already been produced?" —
+ * before any job record exists.
+ */
+export declare function artifactsPresence(projectPath: string, expected: string[] | undefined): {
+    present: number;
+    total: number;
+    missing: string[];
+};
+/** How many of a job's expected artifacts exist on disk. */
+export declare function countPresentArtifacts(job: UnattendedJob): {
+    present: number;
+    total: number;
+    missing: string[];
+};
+/**
+ * Measure the job from disk.
+ *
+ * Never throws: a measurement failure must degrade to "no progress recorded",
+ * which the runner correctly treats as a stall, rather than crashing the drain
+ * that is holding the user's promised work.
+ */
+export declare function measureUnattendedProgress(job: UnattendedJob): BatchOutcome;
+/**
+ * Is the deliverable complete right now?
+ *
+ * Used by surfaces to decide whether to keep scheduling a job at all — a
+ * resumed "continue" turn that finds the work already done must not start a
+ * second book (the ledger's oldest failure mode).
+ */
+export declare function isDeliverableComplete(job: UnattendedJob): boolean;
+/**
+ * The slice of an orchestrator result a surface needs to schedule the rest of
+ * the work.
+ *
+ * Declared STRUCTURALLY (not imported from the orchestrator) because the
+ * gateway, the CLI and the dashboard all consume it, and a shared consumer must
+ * not drag the whole agent graph into its import closure.
+ */
+export interface PendingWorkLike {
+    kind: 'long-form' | 'phased';
+    goal: string;
+    projectPath: string;
+    continuationPrompt: string;
+    expectedArtifacts?: string[];
+    progressLine: string;
+    percent: number;
+    reason: string;
+}
+/**
+ * Schedule the continuation of a run that ended with unfinished work — the
+ * replacement for asking the user to type "continue".
+ *
+ * Returns the scheduled job, or `null` when there is nothing left to do. That
+ * second case matters as much as the first: a run that finished its deliverable
+ * must not enqueue a continuation that would immediately re-run and rebuild it.
+ *
+ * @param pending the orchestrator's `result.pendingWork` (may be undefined)
+ * @param surface who to report to and which drain owns the work
+ */
+export declare function scheduleFromPendingWork(pending: PendingWorkLike | undefined, surface: UnattendedSurface, options?: {
+    deadlineMs?: number;
+    notify?: boolean;
+}): UnattendedJob | null;
+//# sourceMappingURL=unattended-progress.d.ts.map

package/dist/learning/unattended-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unattended-progress.d.ts","sourceRoot":"","sources":["../../src/learning/unattended-progress.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,EAAsB,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExH;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,MAAM,CAAC;AAElC;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,GAC7B;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAWvD;AAED,4DAA4D;AAC5D,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,aAAa,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAE/G;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,aAAa,GAAG,YAAY,CA+C1E;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAGjE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,eAAe,GAAG,SAAS,EACpC,OAAO,EAAE,iBAAiB,EAC1B,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACtD,aAAa,GAAG,IAAI,CAiBtB"}

package/dist/learning/unattended-progress.js

@@ -0,0 +1,147 @@
+/**
+ * Measured progress for an unattended job (enterprise-grade hardening, G11).
+ *
+ * WHY THIS IS ITS OWN MODULE. The runner's central guarantee is that progress
+ * is MEASURED, not claimed: a batch that reports success but did not move the
+ * deliverable is a stall, and three stalls stop the run and ask. That rule is
+ * only as good as the measurement, so the measurement lives in one place,
+ * reading artifacts off disk — and every surface (CLI, dashboard, gateway)
+ * measures the same way instead of each inventing its own idea of "done".
+ *
+ * The two inputs:
+ *   1. the long-form ledger — how much of the CONTENT exists (words, units);
+ *   2. the job's `expectedArtifacts` — the files the deliverable promises
+ *      (site, chapter index, optional tools). For a composite ask this is what
+ *      stops "the prose phase finished" being reported as "the deliverable is
+ *      done" while the site is still missing.
+ */
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { findLatestJob, formatProgress, jobProgress } from './long-form.js';
+import { startUnattendedJob } from './unattended-job.js';
+/**
+ * Weight of the content phase in a composite deliverable's percentage.
+ *
+ * The content IS the deliverable, so it dominates; the surrounding artifacts
+ * are the remaining third. Weighting them any lower would let a beautiful
+ * empty shell sit at 99% after one chapter.
+ */
+export const CONTENT_WEIGHT = 0.7;
+/**
+ * How many expected artifacts exist on disk (relative paths resolved against
+ * the project root).
+ *
+ * Split out from the job-shaped wrapper because the orchestrator asks the same
+ * question at planning time — "has this deliverable already been produced?" —
+ * before any job record exists.
+ */
+export function artifactsPresence(projectPath, expected) {
+    const paths = expected ?? [];
+    if (paths.length === 0)
+        return { present: 0, total: 0, missing: [] };
+    const missing = [];
+    let present = 0;
+    for (const rel of paths) {
+        const abs = isAbsolute(rel) ? rel : resolve(projectPath, rel);
+        if (existsSync(abs))
+            present++;
+        else
+            missing.push(rel);
+    }
+    return { present, total: paths.length, missing };
+}
+/** How many of a job's expected artifacts exist on disk. */
+export function countPresentArtifacts(job) {
+    return artifactsPresence(job.projectPath, job.expectedArtifacts);
+}
+/**
+ * Measure the job from disk.
+ *
+ * Never throws: a measurement failure must degrade to "no progress recorded",
+ * which the runner correctly treats as a stall, rather than crashing the drain
+ * that is holding the user's promised work.
+ */
+export function measureUnattendedProgress(job) {
+    try {
+        const ledger = findLatestJob(job.projectPath);
+        const artifacts = countPresentArtifacts(job);
+        if (!ledger) {
+            // No content ledger for this project: either the job is a phased build
+            // with no prose, or the first batch has not recorded anything yet. The
+            // artifacts are then the only honest signal.
+            if (artifacts.total > 0) {
+                const pct = Math.round((artifacts.present / artifacts.total) * 100);
+                return {
+                    progress: pct,
+                    progressLine: `${artifacts.present}/${artifacts.total} deliverable files present`,
+                    finished: artifacts.present === artifacts.total,
+                };
+            }
+            return { progress: 0, progressLine: 'no progress recorded yet' };
+        }
+        const contentProgress = jobProgress(ledger);
+        const contentPercent = contentProgress.percent;
+        if (artifacts.total === 0) {
+            return {
+                progress: contentPercent,
+                progressLine: formatProgress(ledger),
+                finished: contentProgress.complete,
+            };
+        }
+        const artifactPercent = Math.round((artifacts.present / artifacts.total) * 100);
+        const combined = Math.round(contentPercent * CONTENT_WEIGHT + artifactPercent * (1 - CONTENT_WEIGHT));
+        const finished = contentProgress.complete && artifacts.present === artifacts.total;
+        return {
+            progress: finished ? 100 : combined,
+            progressLine: `${formatProgress(ledger)} · ${artifacts.present}/${artifacts.total} deliverable files` +
+                (artifacts.missing.length > 0 && artifacts.missing.length <= 3
+                    ? ` (missing ${artifacts.missing.join(', ')})`
+                    : ''),
+            finished,
+        };
+    }
+    catch {
+        return { progress: 0, progressLine: 'progress measurement unavailable' };
+    }
+}
+/**
+ * Is the deliverable complete right now?
+ *
+ * Used by surfaces to decide whether to keep scheduling a job at all — a
+ * resumed "continue" turn that finds the work already done must not start a
+ * second book (the ledger's oldest failure mode).
+ */
+export function isDeliverableComplete(job) {
+    const measured = measureUnattendedProgress(job);
+    return measured.finished === true;
+}
+/**
+ * Schedule the continuation of a run that ended with unfinished work — the
+ * replacement for asking the user to type "continue".
+ *
+ * Returns the scheduled job, or `null` when there is nothing left to do. That
+ * second case matters as much as the first: a run that finished its deliverable
+ * must not enqueue a continuation that would immediately re-run and rebuild it.
+ *
+ * @param pending the orchestrator's `result.pendingWork` (may be undefined)
+ * @param surface who to report to and which drain owns the work
+ */
+export function scheduleFromPendingWork(pending, surface, options = {}) {
+    if (!pending)
+        return null;
+    const presence = artifactsPresence(pending.projectPath, pending.expectedArtifacts);
+    const filesComplete = presence.total === 0 || presence.present === presence.total;
+    if (pending.percent >= 100 && filesComplete)
+        return null;
+    return startUnattendedJob({
+        kind: pending.kind,
+        goal: pending.goal,
+        projectPath: pending.projectPath,
+        surface,
+        continuationPrompt: pending.continuationPrompt,
+        ...(pending.expectedArtifacts ? { expectedArtifacts: pending.expectedArtifacts } : {}),
+        ...(options.deadlineMs !== undefined ? { deadlineMs: options.deadlineMs } : {}),
+        ...(options.notify !== undefined ? { notify: options.notify } : {}),
+    }).job;
+}
+//# sourceMappingURL=unattended-progress.js.map

package/dist/learning/unattended-progress.js.map

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

package/dist/learning/working-state.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Working state — the per-project ledger that gives the agent a memory of
+ * what it changed, whether the change was verified, and what the user has
+ * already reported broken (enterprise-grade hardening, G3 + G4).
+ *
+ * WHY THIS EXISTS (the trace audit):
+ * The calculator session ran 15 turns over 77 minutes. Each turn RE-DERIVED
+ * the same root cause from scratch (input tokens grew 2,172 → 7,317), the
+ * model flip-flopped on the diagnosis (found the `id`-mapping bug in turn 23,
+ * declared the CSS "perfectly valid" in turn 25), and its own fixes kept
+ * undoing earlier ones (turn 17 made the converter vanish; turn 21 broke the
+ * dropdowns). Nothing carried the STATE of the work across turns — only the
+ * raw transcript, which is the worst possible carrier.
+ *
+ * This ledger is deliberately DETERMINISTIC and LLM-free: it records facts
+ * (files touched, verified-or-not, user-reported regressions) and formats a
+ * compact block that is injected at the start of the next turn. No summarizer,
+ * no latency, no drift — the same philosophy as `trimThreadBudget`.
+ *
+ * Storage: `~/.nuvira/memory/working-state.json`, keyed by project path.
+ * Honours `NUVIRA_MEMORY_DIR` / `BUFF_MEMORY_DIR` like the reasoning traces.
+ * Every write is best-effort — a ledger write must NEVER break a turn.
+ */
+/** One project's working state — everything worth remembering between turns. */
+export interface ProjectWorkingState {
+    /** Absolute project path (the ledger key). */
+    projectPath: string;
+    /** Files the agent changed, most-recent last (deduped, capped). */
+    filesTouched: string[];
+    /** Distinct tools used across the session (for a quick capability read). */
+    toolsUsed: string[];
+    /** Turns recorded against this project. */
+    turns: number;
+    /**
+     * Consecutive unverified edit turns still outstanding. Reset to 0 the
+     * moment a turn verifies, because a verified state supersedes the backlog.
+     */
+    unverifiedEdits: number;
+    /** Epoch ms of the last turn that verified (ran tests/typecheck/browser). */
+    lastVerifiedAt?: number;
+    /**
+     * What the USER reported broken, newest last (deduped, capped). This is the
+     * regression memory: the exact thing the agent must not re-break or
+     * re-derive next turn.
+     */
+    openIssues: string[];
+    /** How many turns carried a regression signal ("still", "same issue"...). */
+    corrections: number;
+    /** Epoch ms of the last write. */
+    updatedAt: number;
+}
+/** A single finished turn, as recorded by the caller. */
+export interface TurnRecord {
+    /** Files edited this turn (any order; deduped + capped on write). */
+    filesTouched?: string[];
+    /** Tools that ran successfully this turn. */
+    toolsUsed?: readonly string[];
+    /** A verification tool ran successfully this turn. */
+    verified?: boolean;
+    /** The turn mutated the workspace and verified nothing. */
+    unverifiedEdit?: boolean;
+    /** The user's message for this turn (scanned for a regression signal). */
+    userMessage?: string;
+}
+/** Cap on remembered files per project (oldest drop first). */
+export declare const MAX_FILES = 40;
+/** Cap on remembered user-reported issues per project. */
+export declare const MAX_ISSUES = 8;
+/** Cap on remembered tools per project. */
+export declare const MAX_TOOLS = 24;
+/** Normalize a project path so the same project always maps to one entry. */
+export declare function normalizeProjectPath(projectPath: string): string;
+/**
+ * Does the user's message report that something is STILL broken?
+ *
+ * This is the correction signal the audit was built on: the user said
+ * "still same issue", "i don't see any change", "converter is not having any
+ * conversion logic" six turns in a row. Detecting it lets the ledger keep the
+ * issue in front of the agent instead of letting it re-diagnose from zero.
+ *
+ * Deliberately conservative: a bare question ("does this work?") is not a
+ * regression, and neither is a fresh feature request.
+ */
+export declare function detectRegressionSignal(userMessage: string): boolean;
+/** Read one project's state (null when nothing has been recorded). */
+export declare function getWorkingState(projectPath: string): ProjectWorkingState | null;
+/**
+ * Record a finished turn and return the updated state. Best-effort: on any
+ * failure the caller still gets a usable (possibly unchanged) state.
+ *
+ * The rules encode the audit's lessons:
+ * - Touched files accumulate and are capped oldest-first.
+ * - A VERIFIED turn clears the unverified backlog AND the open issues (the
+ *   fix is proven, so the previous report is answered).
+ * - An UNVERIFIED edit turn increments the backlog — the debt the agent owes.
+ * - A regression signal keeps the user's own words as an open issue.
+ */
+export declare function recordWorkingState(projectPath: string, turn: TurnRecord): ProjectWorkingState;
+/** Forget one project (or the whole ledger when no path is given). */
+export declare function clearWorkingState(projectPath?: string): void;
+/**
+ * Format the state as a compact, model-readable block ('' when there is
+ * nothing worth saying — a pristine project must not add noise to the prompt).
+ *
+ * Kept short on purpose: this rides in EVERY turn, so a verbose block would
+ * recreate the very drift it exists to prevent.
+ */
+export declare function formatWorkingState(state: ProjectWorkingState | null, now?: number): string;
+//# sourceMappingURL=working-state.d.ts.map

package/dist/learning/working-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"working-state.d.ts","sourceRoot":"","sources":["../../src/learning/working-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAQH,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IAClC,8CAA8C;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,4EAA4E;IAC5E,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,yDAAyD;AACzD,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,sDAAsD;IACtD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAUD,+DAA+D;AAC/D,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,0DAA0D;AAC1D,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,2CAA2C;AAC3C,eAAO,MAAM,SAAS,KAAK,CAAC;AAkC5B,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAMhE;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAkBnE;AAID,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAG/E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,mBAAmB,CAoE7F;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAQ5D;AAaD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,EAAE,GAAG,GAAE,MAAmB,GAAG,MAAM,CAyBtG"}

package/dist/learning/working-state.js

@@ -0,0 +1,244 @@
+/**
+ * Working state — the per-project ledger that gives the agent a memory of
+ * what it changed, whether the change was verified, and what the user has
+ * already reported broken (enterprise-grade hardening, G3 + G4).
+ *
+ * WHY THIS EXISTS (the trace audit):
+ * The calculator session ran 15 turns over 77 minutes. Each turn RE-DERIVED
+ * the same root cause from scratch (input tokens grew 2,172 → 7,317), the
+ * model flip-flopped on the diagnosis (found the `id`-mapping bug in turn 23,
+ * declared the CSS "perfectly valid" in turn 25), and its own fixes kept
+ * undoing earlier ones (turn 17 made the converter vanish; turn 21 broke the
+ * dropdowns). Nothing carried the STATE of the work across turns — only the
+ * raw transcript, which is the worst possible carrier.
+ *
+ * This ledger is deliberately DETERMINISTIC and LLM-free: it records facts
+ * (files touched, verified-or-not, user-reported regressions) and formats a
+ * compact block that is injected at the start of the next turn. No summarizer,
+ * no latency, no drift — the same philosophy as `trimThreadBudget`.
+ *
+ * Storage: `~/.nuvira/memory/working-state.json`, keyed by project path.
+ * Honours `NUVIRA_MEMORY_DIR` / `BUFF_MEMORY_DIR` like the reasoning traces.
+ * Every write is best-effort — a ledger write must NEVER break a turn.
+ */
+import { envBuff, resolveNuviraHome } from '../config/paths.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+// ─── Constants ──────────────────────────────────────────────────────────────
+const CURRENT_VERSION = 1;
+/** Cap on remembered files per project (oldest drop first). */
+export const MAX_FILES = 40;
+/** Cap on remembered user-reported issues per project. */
+export const MAX_ISSUES = 8;
+/** Cap on remembered tools per project. */
+export const MAX_TOOLS = 24;
+// ─── Storage ────────────────────────────────────────────────────────────────
+function memoryDir() {
+    return envBuff('MEMORY_DIR') || join(resolveNuviraHome(), 'memory');
+}
+function statePath() {
+    return join(memoryDir(), 'working-state.json');
+}
+function readFileSafe() {
+    try {
+        if (!existsSync(statePath()))
+            return { version: CURRENT_VERSION, projects: {} };
+        const data = JSON.parse(readFileSync(statePath(), 'utf-8'));
+        if (!data || typeof data !== 'object' || !data.projects || typeof data.projects !== 'object') {
+            return { version: CURRENT_VERSION, projects: {} };
+        }
+        return data;
+    }
+    catch {
+        return { version: CURRENT_VERSION, projects: {} };
+    }
+}
+function writeFileSafe(data) {
+    try {
+        if (!existsSync(memoryDir()))
+            mkdirSync(memoryDir(), { recursive: true });
+        writeFileSync(statePath(), JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch {
+        // Best-effort — the ledger must never break a turn.
+    }
+}
+/** Normalize a project path so the same project always maps to one entry. */
+export function normalizeProjectPath(projectPath) {
+    try {
+        return resolve(projectPath);
+    }
+    catch {
+        return projectPath;
+    }
+}
+// ─── Regression signals ─────────────────────────────────────────────────────
+/**
+ * Does the user's message report that something is STILL broken?
+ *
+ * This is the correction signal the audit was built on: the user said
+ * "still same issue", "i don't see any change", "converter is not having any
+ * conversion logic" six turns in a row. Detecting it lets the ledger keep the
+ * issue in front of the agent instead of letting it re-diagnose from zero.
+ *
+ * Deliberately conservative: a bare question ("does this work?") is not a
+ * regression, and neither is a fresh feature request.
+ */
+export function detectRegressionSignal(userMessage) {
+    const text = (userMessage || '').trim();
+    if (!text)
+        return false;
+    if (text.length > 600)
+        return false; // a long brief is a new task, not a correction
+    const patterns = [
+        /\bstill\b/i,
+        /\bsame (?:issue|problem|bug|thing|error|behaviou?r)\b/i,
+        /\bnot (?:working|fixed|visible|showing|appearing|there)\b/i,
+        /\bdoesn'?t work\b/i,
+        /\bdidn'?t work\b/i,
+        /\bno (?:change|changes|luck|effect)\b/i,
+        /\bi (?:still )?(?:can'?t|cannot|don'?t) (?:see|find)\b/i,
+        /\byou (?:broke|broke?n)\b/i,
+        /\bregress(?:ion|ed)?\b/i,
+        /\bit'?s (?:blank|empty|gone|missing)\b/i,
+        /\bagain\b/i,
+    ];
+    return patterns.some((re) => re.test(text));
+}
+// ─── API ────────────────────────────────────────────────────────────────────
+/** Read one project's state (null when nothing has been recorded). */
+export function getWorkingState(projectPath) {
+    const data = readFileSafe();
+    return data.projects[normalizeProjectPath(projectPath)] ?? null;
+}
+/**
+ * Record a finished turn and return the updated state. Best-effort: on any
+ * failure the caller still gets a usable (possibly unchanged) state.
+ *
+ * The rules encode the audit's lessons:
+ * - Touched files accumulate and are capped oldest-first.
+ * - A VERIFIED turn clears the unverified backlog AND the open issues (the
+ *   fix is proven, so the previous report is answered).
+ * - An UNVERIFIED edit turn increments the backlog — the debt the agent owes.
+ * - A regression signal keeps the user's own words as an open issue.
+ */
+export function recordWorkingState(projectPath, turn) {
+    const key = normalizeProjectPath(projectPath);
+    const data = readFileSafe();
+    const now = Date.now();
+    const prev = data.projects[key] ??
+        {
+            projectPath: key,
+            filesTouched: [],
+            toolsUsed: [],
+            turns: 0,
+            unverifiedEdits: 0,
+            openIssues: [],
+            corrections: 0,
+            updatedAt: now,
+        };
+    const next = { ...prev, filesTouched: [...prev.filesTouched], toolsUsed: [...prev.toolsUsed], openIssues: [...prev.openIssues] };
+    next.turns = prev.turns + 1;
+    next.updatedAt = now;
+    // Files — dedupe (move-to-end so recency is meaningful) then cap.
+    for (const f of turn.filesTouched ?? []) {
+        if (!f)
+            continue;
+        const idx = next.filesTouched.indexOf(f);
+        if (idx !== -1)
+            next.filesTouched.splice(idx, 1);
+        next.filesTouched.push(f);
+    }
+    if (next.filesTouched.length > MAX_FILES) {
+        next.filesTouched = next.filesTouched.slice(-MAX_FILES);
+    }
+    // Tools — distinct, capped.
+    for (const t of turn.toolsUsed ?? []) {
+        if (t && !next.toolsUsed.includes(t))
+            next.toolsUsed.push(t);
+    }
+    if (next.toolsUsed.length > MAX_TOOLS) {
+        next.toolsUsed = next.toolsUsed.slice(-MAX_TOOLS);
+    }
+    // Verification debt.
+    if (turn.verified) {
+        next.unverifiedEdits = 0;
+        next.lastVerifiedAt = now;
+        // A proven fix answers the open reports.
+        next.openIssues = [];
+    }
+    else if (turn.unverifiedEdit) {
+        next.unverifiedEdits = prev.unverifiedEdits + 1;
+    }
+    // Regression memory — keep the user's own words.
+    const msg = (turn.userMessage || '').trim();
+    if (msg && detectRegressionSignal(msg)) {
+        next.corrections = prev.corrections + 1;
+        const short = msg.replace(/\s+/g, ' ').slice(0, 200);
+        if (!next.openIssues.includes(short))
+            next.openIssues.push(short);
+        if (next.openIssues.length > MAX_ISSUES)
+            next.openIssues = next.openIssues.slice(-MAX_ISSUES);
+    }
+    data.projects[key] = next;
+    // Bound the file: keep the most recently updated projects only.
+    const entries = Object.entries(data.projects);
+    if (entries.length > 50) {
+        entries.sort((a, b) => b[1].updatedAt - a[1].updatedAt);
+        data.projects = Object.fromEntries(entries.slice(0, 50));
+    }
+    writeFileSafe(data);
+    return next;
+}
+/** Forget one project (or the whole ledger when no path is given). */
+export function clearWorkingState(projectPath) {
+    if (!projectPath) {
+        writeFileSafe({ version: CURRENT_VERSION, projects: {} });
+        return;
+    }
+    const data = readFileSafe();
+    delete data.projects[normalizeProjectPath(projectPath)];
+    writeFileSafe(data);
+}
+// ─── Formatting (the injected block) ────────────────────────────────────────
+function relativeAge(ts, now) {
+    const mins = Math.max(0, Math.round((now - ts) / 60_000));
+    if (mins < 1)
+        return 'just now';
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.round(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.round(hours / 24)}d ago`;
+}
+/**
+ * Format the state as a compact, model-readable block ('' when there is
+ * nothing worth saying — a pristine project must not add noise to the prompt).
+ *
+ * Kept short on purpose: this rides in EVERY turn, so a verbose block would
+ * recreate the very drift it exists to prevent.
+ */
+export function formatWorkingState(state, now = Date.now()) {
+    if (!state)
+        return '';
+    const lines = [];
+    if (state.filesTouched.length > 0) {
+        const files = state.filesTouched.slice(-8);
+        lines.push(`• Files changed this session (${state.filesTouched.length}): ${files.join(', ')}${state.filesTouched.length > files.length ? ', …' : ''}`);
+    }
+    if (state.unverifiedEdits > 0) {
+        lines.push(`• ⚠️ ${state.unverifiedEdits} edit turn(s) were NEVER verified — do not assume they work; re-check before building on them.`);
+    }
+    if (state.lastVerifiedAt !== undefined) {
+        lines.push(`• Last verified: ${relativeAge(state.lastVerifiedAt, now)} (a test/typecheck/browser run passed).`);
+    }
+    if (state.openIssues.length > 0) {
+        const latest = state.openIssues[state.openIssues.length - 1];
+        lines.push(`• User has reported ${state.corrections} regression(s). Most recent report: "${latest}" — fix THIS, do not re-diagnose from scratch.`);
+    }
+    if (lines.length === 0)
+        return '';
+    return `[Working state — carried from previous turns in THIS project]\n${lines.join('\n')}`;
+}
+//# sourceMappingURL=working-state.js.map

package/dist/learning/working-state.js.map

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