aura-code 0.5.0 → 0.10.1

package/dist/machina/spec.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * `:machina` — the Abstract Agent Machine (AAM).
+ *
+ * This module states a formal model of what `aura-code` *is*, independent of
+ * which LLM happens to be plugged in, and then checks every structural claim
+ * it makes against the real source tree at run time (see verify.ts). A spec
+ * that asserts "the main loop is at loop.ts:127" and never re-checks that
+ * line drifts silently as the code changes — this one refuses to.
+ *
+ * ── The model ──────────────────────────────────────────────────────────────
+ * AAM is the 5-tuple  (S, P, O, δ, s0):
+ *
+ *   S   — state space. A state is the full conversation history plus loop
+ *         counters: s = (history, turns, usage). Every run lives inside S.
+ *   P   — primitives. The finite, fixed set of tool definitions the machine
+ *         can invoke (read_file, run_command, edit, ...). P is finite and
+ *         enumerable — this is NOT where unboundedness comes from.
+ *   O   — the oracle. A function history -> {text, tool_calls, stop_reason}.
+ *         The oracle is the ONLY part of the tuple that is swappable: it can
+ *         be an LLM, a human, a rule table, or another AAM run recursively.
+ *         Swapping the oracle does not change S, P, δ, or s0.
+ *   δ   — the transition function. δ(s, o(s)) -> s'. Concretely: take the
+ *         oracle's output, run it through the safety gate, execute any tool
+ *         calls against P, fold the results back into history, and check
+ *         halting conditions.
+ *   s0  — the initial state: empty history + the user's task as the first
+ *         message.
+ *
+ * ── Why this matters, precisely ────────────────────────────────────────────
+ * Because δ can simulate a Turing machine's transition function (the oracle
+ * can be made to emit "move tape head" tool calls and the primitives can
+ * implement a tape as a file), AAM is Turing-complete *in principle*, for
+ * an UNBOUNDED machine (infinite turns, infinite context). Turing-completeness
+ * is the ceiling for computability — a quantum computer does not raise this
+ * ceiling; it changes the *complexity* of specific problems (factoring,
+ * search), not which problems are solvable at all. So "make the oracle
+ * quantum" would be a speed upgrade to O, not a power upgrade to the tuple.
+ *
+ * Turing-completeness has a cost the spec must not hide: the Halting Problem
+ * is undecidable for an unbounded AAM — there is no general procedure that
+ * decides, for an arbitrary task, whether the loop ever stops. This is
+ * exactly why real aura-code is NOT the unbounded machine: maxTurns and the
+ * context compactor are deliberate, finite approximations that trade a
+ * sliver of theoretical power for guaranteed termination. The unbounded
+ * machine is elegant on paper and undecidable in practice; the bounded
+ * machine is what you can actually run.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AAM_LIMITS_NOTE = exports.AAM_PREAMBLE = exports.AAM_CLAIMS = void 0;
+exports.AAM_CLAIMS = [
+    {
+        id: 'main-loop',
+        component: 'delta',
+        description: 'The main transition loop — one iteration is one application of δ. The turn budget is checked inside the loop so it can widen once when work is still in progress.',
+        file: 'src/agent/loop.ts',
+        line: 172,
+        mustContain: 'while (true)',
+    },
+    {
+        id: 'oracle-call',
+        component: 'O',
+        description: "The oracle invocation — O(history) -> stream of {text, tool_calls, stop_reason}.",
+        file: 'src/agent/loop.ts',
+        line: 235,
+        mustContain: 'provider.stream(',
+    },
+    {
+        id: 'safety-gate',
+        component: 'delta',
+        description: 'The safety gate inside δ — tool calls are checked against permissions before primitives execute.',
+        file: 'src/agent/loop.ts',
+        line: 349,
+        mustContain: 'permissions.check(',
+    },
+    {
+        id: 'compaction-threshold',
+        component: 'limit',
+        description: 'The state-space pressure-relief valve: history is compacted on a generational ladder (55%, then 70%, then 85% of the context window), keeping S finite in practice.',
+        file: 'src/agent/compactor.ts',
+        line: 13,
+        mustContain: 'LADDER = [0.55, 0.70, 0.85]',
+    },
+    {
+        id: 'compaction-check',
+        component: 'limit',
+        description: 'The actual threshold comparison that triggers compaction.',
+        file: 'src/agent/compactor.ts',
+        line: 227,
+        mustContain: 'if (totalTokens < threshold) return false;',
+    },
+    {
+        id: 'max-turns',
+        component: 'limit',
+        description: 'T_max — the halting bound that makes the REAL machine decidable (150 turns by default, widening at most once for in-progress work), unlike the unbounded theoretical AAM.',
+        file: 'src/config/defaults.ts',
+        line: 10,
+        mustContain: 'maxTurns: 150',
+    },
+    {
+        id: 'primitives',
+        component: 'P',
+        description: 'P — the finite, enumerable set of tool primitives the machine can invoke.',
+        file: 'src/tools/index.ts',
+        line: 30,
+        mustContain: 'export const TOOL_DEFINITIONS',
+    },
+];
+exports.AAM_PREAMBLE = 'Aura is not "an LLM with a loop around it." It is an Abstract Agent Machine: ' +
+    'a 5-tuple (S, P, O, δ, s0) whose computational power comes from its structure ' +
+    '— state space, primitives, transition function — not from which oracle (LLM, ' +
+    'human, rule table) happens to be plugged into O. Swap the oracle and the ' +
+    'machine is unchanged. This is what makes Aura provider-agnostic by ' +
+    'construction, not by convention.';
+exports.AAM_LIMITS_NOTE = 'The UNBOUNDED version of this machine (infinite turns, infinite context) is ' +
+    'Turing-complete, which means the Halting Problem is undecidable for it: no ' +
+    'general test can say whether an arbitrary task ever finishes. Real aura-code ' +
+    'is deliberately NOT that machine — maxTurns and the context compactor below ' +
+    'are the finite bounds that buy guaranteed termination at the cost of some ' +
+    'theoretical power. A quantum oracle would not restore that power: ' +
+    'Turing-completeness is already the ceiling for what is computable at all; ' +
+    'quantum computation changes the cost of solving certain problems, not which ' +
+    'problems are solvable.';
+//# sourceMappingURL=spec.js.map

package/dist/machina/spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.js","sourceRoot":"","sources":["../../src/machina/spec.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;;;AAcU,QAAA,UAAU,GAAsB;IAC3C;QACE,EAAE,EAAE,WAAW;QACf,SAAS,EAAE,OAAO;QAClB,WAAW,EAAE,mKAAmK;QAChL,IAAI,EAAE,mBAAmB;QACzB,IAAI,EAAE,GAAG;QACT,WAAW,EAAE,cAAc;KAC5B;IACD;QACE,EAAE,EAAE,aAAa;QACjB,SAAS,EAAE,GAAG;QACd,WAAW,EAAE,kFAAkF;QAC/F,IAAI,EAAE,mBAAmB;QACzB,IAAI,EAAE,GAAG;QACT,WAAW,EAAE,kBAAkB;KAChC;IACD;QACE,EAAE,EAAE,aAAa;QACjB,SAAS,EAAE,OAAO;QAClB,WAAW,EAAE,kGAAkG;QAC/G,IAAI,EAAE,mBAAmB;QACzB,IAAI,EAAE,GAAG;QACT,WAAW,EAAE,oBAAoB;KAClC;IACD;QACE,EAAE,EAAE,sBAAsB;QAC1B,SAAS,EAAE,OAAO;QAClB,WAAW,EAAE,qKAAqK;QAClL,IAAI,EAAE,wBAAwB;QAC9B,IAAI,EAAE,EAAE;QACR,WAAW,EAAE,6BAA6B;KAC3C;IACD;QACE,EAAE,EAAE,kBAAkB;QACtB,SAAS,EAAE,OAAO;QAClB,WAAW,EAAE,2DAA2D;QACxE,IAAI,EAAE,wBAAwB;QAC9B,IAAI,EAAE,GAAG;QACT,WAAW,EAAE,4CAA4C;KAC1D;IACD;QACE,EAAE,EAAE,WAAW;QACf,SAAS,EAAE,OAAO;QAClB,WAAW,EAAE,2KAA2K;QACxL,IAAI,EAAE,wBAAwB;QAC9B,IAAI,EAAE,EAAE;QACR,WAAW,EAAE,eAAe;KAC7B;IACD;QACE,EAAE,EAAE,YAAY;QAChB,SAAS,EAAE,GAAG;QACd,WAAW,EAAE,2EAA2E;QACxF,IAAI,EAAE,oBAAoB;QAC1B,IAAI,EAAE,EAAE;QACR,WAAW,EAAE,+BAA+B;KAC7C;CACF,CAAC;AAEW,QAAA,YAAY,GACvB,+EAA+E;IAC/E,gFAAgF;IAChF,+EAA+E;IAC/E,2EAA2E;IAC3E,qEAAqE;IACrE,kCAAkC,CAAC;AAExB,QAAA,eAAe,GAC1B,8EAA8E;IAC9E,6EAA6E;IAC7E,+EAA+E;IAC/E,8EAA8E;IAC9E,4EAA4E;IAC5E,oEAAoE;IACpE,4EAA4E;IAC5E,8EAA8E;IAC9E,wBAAwB,CAAC"}

package/dist/machina/verify.d.ts

@@ -0,0 +1,39 @@
+import { type VerifiableClaim } from './spec.js';
+export interface ClaimResult extends VerifiableClaim {
+    /**
+     * verified — mustContain found at the recorded line (exact anchor).
+     * drifted  — mustContain found elsewhere in the file: the claim still
+     *            HOLDS, only its line anchor is stale (see foundLine). This is
+     *            a passing state — pure line churn is noise, not signal.
+     * missing  — mustContain appears nowhere in the file (or the file is
+     *            unreadable): the claim is genuinely false. The only failure.
+     */
+    status: 'verified' | 'drifted' | 'missing';
+    /** The actual line content found at the recorded line, if the file exists. */
+    actualLine?: string;
+    /** Where mustContain actually lives now (1-indexed) — set when drifted. */
+    foundLine?: number;
+}
+/**
+ * Resolve the aura-code installation's own root directory, the same way
+ * telegram-bot.ts locates its repo for systemd unit generation. From a
+ * compiled module at dist/machina/verify.js, '../..' lands at the repo root
+ * (dist/machina -> dist -> root). This is intentionally independent of
+ * process.cwd(), since :machina describes aura-code's own machinery, not
+ * whatever project the user happens to be running it inside.
+ */
+export declare function resolveAuraRepoRoot(): string;
+export interface VerificationReport {
+    results: ClaimResult[];
+    verifiedCount: number;
+    /** Claims that hold but whose line anchor is stale — passing, needs re-anchoring (see repair.ts). */
+    drifted: ClaimResult[];
+    /** Claims whose content is genuinely gone — the only real failures. */
+    missing: ClaimResult[];
+}
+/**
+ * Verify every structural claim the spec makes. `repoRoot` should be the
+ * aura-code installation's own source root — pass `__dirname`-derived paths
+ * from the CLI entry point, not the user's project root.
+ */
+export declare function verifyAamClaims(repoRoot: string): VerificationReport;

package/dist/machina/verify.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAuraRepoRoot = resolveAuraRepoRoot;
+exports.verifyAamClaims = verifyAamClaims;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const spec_js_1 = require("./spec.js");
+/**
+ * Check a single claim against the real file on disk. `repoRoot` is the
+ * aura-code repository root (NOT the user's current project — the AAM
+ * describes aura-code's own machinery, regardless of what project it's
+ * currently being run inside).
+ *
+ * The recorded line number is a lookup hint, not the pass/fail condition:
+ * whether the claim is TRUE depends only on the content existing in the file.
+ */
+function verifyClaim(repoRoot, claim) {
+    const filePath = path.join(repoRoot, claim.file);
+    let lines;
+    try {
+        lines = fs.readFileSync(filePath, 'utf8').split('\n');
+    }
+    catch {
+        return { ...claim, status: 'missing' };
+    }
+    const actual = lines[claim.line - 1] ?? '';
+    if (actual.includes(claim.mustContain)) {
+        return { ...claim, status: 'verified', actualLine: actual.trim() };
+    }
+    // Anchor miss — search the whole file before declaring the claim false.
+    const foundIdx = lines.findIndex(l => l.includes(claim.mustContain));
+    if (foundIdx !== -1) {
+        return { ...claim, status: 'drifted', actualLine: actual.trim(), foundLine: foundIdx + 1 };
+    }
+    return { ...claim, status: 'missing', actualLine: actual.trim() };
+}
+/**
+ * Resolve the aura-code installation's own root directory, the same way
+ * telegram-bot.ts locates its repo for systemd unit generation. From a
+ * compiled module at dist/machina/verify.js, '../..' lands at the repo root
+ * (dist/machina -> dist -> root). This is intentionally independent of
+ * process.cwd(), since :machina describes aura-code's own machinery, not
+ * whatever project the user happens to be running it inside.
+ */
+function resolveAuraRepoRoot() {
+    return path.resolve(__dirname, '../..');
+}
+/**
+ * Verify every structural claim the spec makes. `repoRoot` should be the
+ * aura-code installation's own source root — pass `__dirname`-derived paths
+ * from the CLI entry point, not the user's project root.
+ */
+function verifyAamClaims(repoRoot) {
+    const results = spec_js_1.AAM_CLAIMS.map(c => verifyClaim(repoRoot, c));
+    return {
+        results,
+        verifiedCount: results.filter(r => r.status === 'verified').length,
+        drifted: results.filter(r => r.status === 'drifted'),
+        missing: results.filter(r => r.status === 'missing'),
+    };
+}
+//# sourceMappingURL=verify.js.map

package/dist/machina/verify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.js","sourceRoot":"","sources":["../../src/machina/verify.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,kDAEC;AAiBD,0CAQC;AApFD,uCAAyB;AACzB,2CAA6B;AAC7B,uCAA6D;AAkB7D;;;;;;;;GAQG;AACH,SAAS,WAAW,CAAC,QAAgB,EAAE,KAAsB;IAC3D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IACjD,IAAI,KAAe,CAAC;IACpB,IAAI,CAAC;QACH,KAAK,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;IACzC,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3C,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC;QACvC,OAAO,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;IACrE,CAAC;IACD,wEAAwE;IACxE,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IACrE,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC;QACpB,OAAO,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,QAAQ,GAAG,CAAC,EAAE,CAAC;IAC7F,CAAC;IACD,OAAO,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;AACpE,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,mBAAmB;IACjC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;AAC1C,CAAC;AAYD;;;;GAIG;AACH,SAAgB,eAAe,CAAC,QAAgB;IAC9C,MAAM,OAAO,GAAG,oBAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9D,OAAO;QACL,OAAO;QACP,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC,MAAM;QAClE,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC;QACpD,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC;KACrD,CAAC;AACJ,CAAC"}

package/dist/mining/extract.d.ts

@@ -0,0 +1,34 @@
+import type { TaskCategory } from '../ruby/types.js';
+export interface MinedConcept {
+    /** Short slug-like identifier for the concept (e.g. "verification_before_completion"). */
+    concept: string;
+    /** Category this concept was mined from. */
+    category: TaskCategory;
+    /** Representative example task strings from the cluster (max 5, shortest first). */
+    examples: string[];
+    /** Number of episodes that contributed to this concept. */
+    frequency: number;
+    /** Mechanical confidence: cluster cohesion combined with cluster size relative to total. */
+    confidence: number;
+    /** Depth at which this concept was extracted (1, 2, or 3). */
+    depth: number;
+    /** The shared keywords that define this cluster. */
+    keywords: string[];
+}
+export interface MiningResult {
+    concepts: MinedConcept[];
+    episodeCount: number;
+    /** Episodes that didn't cluster into anything meaningful — too rare or too unique. */
+    unclustered: number;
+}
+/**
+ * Run Baby Ruby: mine episodes for structural patterns without any LLM call.
+ *
+ * Pass 1: group by taskCategory (free, already on every episode).
+ * Pass 2-3: within each category, recursively split by keyword overlap
+ *           until no meaningful further split exists or MAX_DEPTH is hit.
+ *
+ * Returns a flat list of MinedConcept — Papa Ruby (future) will read these
+ * and turn the most useful ones into actual training/instruction data.
+ */
+export declare function mineExperience(projectRoot: string): Promise<MiningResult>;

package/dist/mining/extract.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mineExperience = mineExperience;
+const episode_capture_js_1 = require("../ruby/episode-capture.js");
+/**
+ * Baby Ruby — experience mining, not learning.
+ *
+ * Finds structure in raw episode data using pure statistics: clustering,
+ * frequency counts, keyword overlap. NO LLM calls. This is deliberate:
+ * Baby Ruby's job is to be reliable, boring infrastructure — the kind that
+ * doesn't hallucinate, doesn't cost tokens, and produces the same output
+ * given the same input every time.
+ *
+ * This is the "observation" stage of a three-stage cognitive pipeline:
+ *
+ *   episodes (raw experience)
+ *     -> Baby Ruby (this file)    — no LLM, finds structure
+ *       -> concepts (this file's output)
+ *         -> Papa Ruby (future)   — local LLM, reasons about concepts
+ *           -> training data / refined knowledge
+ *
+ * Baby Ruby does NOT produce instruction/output training pairs. That is
+ * explicitly Papa Ruby's job, on top of Baby Ruby's structure. Keeping this
+ * separation means Baby Ruby never needs a model, a provider, an API key,
+ * or a network call — it's pure, fast, and always available.
+ *
+ * Three-pass recursive clustering:
+ *   Pass 1 — broad clusters by taskCategory (research/implementation/
+ *            review/refactor/other). This is free — the category already
+ *            exists on every episode.
+ *   Pass 2 — sub-clusters within each category by keyword overlap (shared
+ *            significant words in task text, e.g. "auth", "type", "test").
+ *   Pass 3 — extract stable concepts from sub-clusters that meet a minimum
+ *            size and produce a confidence score.
+ *
+ * Termination condition (real, not infinite recursion):
+ *   Recursion stops when a sub-cluster pass finds no split that produces
+ *   two groups each above MIN_CLUSTER_SIZE, OR when MAX_DEPTH is reached.
+ *   This is a depth-bounded, size-bounded recursion — it always halts.
+ */
+const MIN_CLUSTER_SIZE = 3;
+const MAX_DEPTH = 3;
+const STOPWORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'in', 'on', 'at', 'to', 'for',
+    'of', 'and', 'or', 'but', 'this', 'that', 'with', 'it', 'as', 'be', 'by',
+    'from', 'has', 'have', 'had', 'do', 'does', 'did', 'not', 'no', 'so', 'if',
+    'then', 'there', 'here', 'what', 'when', 'where', 'how', 'why', 'which',
+    'who', 'will', 'would', 'can', 'could', 'should', 'i', 'you', 'we', 'they',
+    'my', 'your', 'our', 'their', 'me', 'us', 'them',
+]);
+/** Extract significant (non-stopword, length > 2) lowercase words from task text. */
+function significantWords(task) {
+    return task
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !STOPWORDS.has(w));
+}
+/** Jaccard-style overlap between two word sets, in [0, 1]. */
+function overlap(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let shared = 0;
+    for (const w of a)
+        if (b.has(w))
+            shared++;
+    const union = a.size + b.size - shared;
+    return union === 0 ? 0 : shared / union;
+}
+/**
+ * Group episodes by shared keywords using a simple greedy clustering pass.
+ * Not k-means, not embeddings — deliberately simple, deterministic, fast.
+ * Each episode joins the first existing cluster it overlaps with above
+ * OVERLAP_THRESHOLD; otherwise it starts a new cluster.
+ */
+const OVERLAP_THRESHOLD = 0.15;
+function clusterByKeywords(episodes) {
+    const wordSets = episodes.map(e => new Set(significantWords(e.task)));
+    const clusters = [];
+    for (let i = 0; i < episodes.length; i++) {
+        const ep = episodes[i];
+        const words = wordSets[i];
+        let placed = false;
+        for (const cluster of clusters) {
+            // Compare against the cluster's combined word set (union of members so far).
+            const clusterWords = new Set();
+            for (const ws of cluster.wordSets)
+                for (const w of ws)
+                    clusterWords.add(w);
+            if (overlap(words, clusterWords) >= OVERLAP_THRESHOLD) {
+                cluster.episodes.push(ep);
+                cluster.wordSets.push(words);
+                placed = true;
+                break;
+            }
+        }
+        if (!placed) {
+            clusters.push({ episodes: [ep], wordSets: [words] });
+        }
+    }
+    return clusters
+        .filter(c => c.episodes.length >= MIN_CLUSTER_SIZE)
+        .map(c => {
+        // Find the words shared by the most members — the cluster's defining keywords.
+        const counts = new Map();
+        for (const ws of c.wordSets)
+            for (const w of ws)
+                counts.set(w, (counts.get(w) ?? 0) + 1);
+        const keywords = [...counts.entries()]
+            .filter(([, count]) => count >= Math.max(2, Math.ceil(c.episodes.length * 0.4)))
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 6)
+            .map(([w]) => w);
+        return { episodes: c.episodes, keywords, depth: 0 };
+    });
+}
+/**
+ * Compute keywords for a leaf node that won't be split further — either
+ * because it hit MAX_DEPTH, or because it's too small to split into two
+ * valid sub-clusters. Without this, small categories (3-5 episodes) would
+ * surface as a "concept" with empty keywords, which is meaningless: a bare
+ * category label isn't a concept on its own.
+ */
+function leafKeywords(episodes) {
+    const counts = new Map();
+    for (const ep of episodes) {
+        for (const w of new Set(significantWords(ep.task))) {
+            counts.set(w, (counts.get(w) ?? 0) + 1);
+        }
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count >= Math.max(2, Math.ceil(episodes.length * 0.4)))
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 6)
+        .map(([w]) => w);
+}
+function recursiveSplit(node) {
+    if (node.depth >= MAX_DEPTH) {
+        return [{ ...node, keywords: node.keywords.length > 0 ? node.keywords : leafKeywords(node.episodes) }];
+    }
+    if (node.episodes.length < MIN_CLUSTER_SIZE * 2) {
+        // Too small to split into two valid clusters — still compute keywords
+        // so this leaf carries real structure instead of an empty label.
+        return [{ ...node, keywords: node.keywords.length > 0 ? node.keywords : leafKeywords(node.episodes) }];
+    }
+    const subClusters = clusterByKeywords(node.episodes);
+    // No real split: either zero sub-clusters formed, or exactly one sub-cluster
+    // that contains essentially all the same episodes (no new structure found).
+    const isRealSplit = subClusters.length >= 2 ||
+        (subClusters.length === 1 && subClusters[0].episodes.length < node.episodes.length);
+    if (!isRealSplit) {
+        return [{ ...node, keywords: node.keywords.length > 0 ? node.keywords : leafKeywords(node.episodes) }];
+    }
+    const deepened = subClusters.map(c => ({ ...c, depth: node.depth + 1 }));
+    return deepened.flatMap(recursiveSplit);
+}
+/** Mechanical confidence: cluster cohesion (size) weighted against the total episode pool. */
+function computeConfidence(clusterSize, totalEpisodes, depth) {
+    const sizeRatio = totalEpisodes > 0 ? clusterSize / totalEpisodes : 0;
+    // Deeper clusters are more specific — slightly boost confidence for depth,
+    // since a stable pattern surviving 2-3 splits is more meaningful than a
+    // broad depth-1 cluster that's just "all coding tasks."
+    const depthBonus = Math.min(depth * 0.05, 0.15);
+    const raw = Math.min(1, sizeRatio * 3 + depthBonus); // *3 so e.g. 17/100 episodes -> 0.51+bonus, not 0.17
+    return Math.round(raw * 100) / 100;
+}
+function slugifyConcept(keywords, category) {
+    const base = keywords.length > 0 ? keywords.slice(0, 3).join('_') : category;
+    return base.toLowerCase().replace(/[^a-z0-9_]/g, '');
+}
+function leafToConcept(leaf, category, totalEpisodes) {
+    const sorted = [...leaf.episodes].sort((a, b) => a.task.length - b.task.length);
+    const examples = sorted.slice(0, 5).map(e => e.task.slice(0, 140));
+    return {
+        concept: slugifyConcept(leaf.keywords, category),
+        category,
+        examples,
+        frequency: leaf.episodes.length,
+        confidence: computeConfidence(leaf.episodes.length, totalEpisodes, leaf.depth),
+        depth: Math.max(1, leaf.depth),
+        keywords: leaf.keywords,
+    };
+}
+/**
+ * Run Baby Ruby: mine episodes for structural patterns without any LLM call.
+ *
+ * Pass 1: group by taskCategory (free, already on every episode).
+ * Pass 2-3: within each category, recursively split by keyword overlap
+ *           until no meaningful further split exists or MAX_DEPTH is hit.
+ *
+ * Returns a flat list of MinedConcept — Papa Ruby (future) will read these
+ * and turn the most useful ones into actual training/instruction data.
+ */
+async function mineExperience(projectRoot) {
+    const episodes = await (0, episode_capture_js_1.loadEpisodes)(projectRoot);
+    if (episodes.length === 0) {
+        return { concepts: [], episodeCount: 0, unclustered: 0 };
+    }
+    // Pass 1: broad clusters by category — always free, no clustering needed.
+    const byCategory = new Map();
+    for (const ep of episodes) {
+        const list = byCategory.get(ep.taskCategory) ?? [];
+        list.push(ep);
+        byCategory.set(ep.taskCategory, list);
+    }
+    const allConcepts = [];
+    let clusteredCount = 0;
+    for (const [category, categoryEpisodes] of byCategory) {
+        if (categoryEpisodes.length < MIN_CLUSTER_SIZE)
+            continue; // too rare to mine
+        // Pass 2-3: recursive keyword splitting within this category.
+        const initialNode = { episodes: categoryEpisodes, keywords: [], depth: 0 };
+        const leaves = recursiveSplit(initialNode);
+        for (const leaf of leaves) {
+            if (leaf.episodes.length < MIN_CLUSTER_SIZE)
+                continue;
+            allConcepts.push(leafToConcept(leaf, category, episodes.length));
+            clusteredCount += leaf.episodes.length;
+        }
+    }
+    // Sort by confidence descending — most stable/significant concepts first.
+    allConcepts.sort((a, b) => b.confidence - a.confidence);
+    return {
+        concepts: allConcepts,
+        episodeCount: episodes.length,
+        unclustered: episodes.length - clusteredCount,
+    };
+}
+//# sourceMappingURL=extract.js.map

package/dist/mining/extract.js.map

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

package/dist/mining/refine.d.ts

@@ -0,0 +1,28 @@
+import type { TrainingExample, RubyConfig } from '../ruby/types.js';
+import type { MinedConcept } from './extract.js';
+export interface RefinementResult {
+    /** Concepts that were judged actionable and written as training examples. */
+    accepted: TrainingExample[];
+    /** Concepts judged noise (or the model failed) — not written. */
+    rejected: number;
+    /** Concepts skipped before even calling the model (below confidence/frequency gate). */
+    skipped: number;
+    /** Path to the .jsonl file new examples were appended to, if any were written. */
+    outputPath?: string;
+}
+/**
+ * Run Papa Ruby over a set of Baby Ruby's concepts.
+ *
+ * Gates BEFORE calling the model: concepts below MIN_CONFIDENCE_TO_REFINE
+ * or MIN_FREQUENCY_TO_REFINE are skipped entirely (not worth a model call
+ * to judge — Baby Ruby's own confidence already says this is weak signal).
+ *
+ * Accepted training examples are appended to training-data/<date>.jsonl.
+ * Never overwrites — each run appends, since this mirrors an append-only
+ * event log philosophy, same as dreams/.
+ */
+export declare function refineConcepts(opts: {
+    projectRoot: string;
+    concepts: MinedConcept[];
+    rubyConfig?: RubyConfig;
+}): Promise<RefinementResult>;