haansi 0.1.48 → 0.1.50

package/dist/haansi.js

@@ -95,7 +95,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "haansi",
-      version: "0.1.48",
+      version: "0.1.50",
       description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
       bin: {
         haansi: "./dist/haansi.js"
@@ -651,9 +651,10 @@ OpenAI Codex \u2014 configured in ${CODEX_CONFIG}`);
 }
 function refreshClaudeConfigTokens(config6, token) {
   const changed = [];
+  const projects = config6.projects ?? {};
   const scopes = [
     config6.mcpServers,
-    ...Object.values(config6.projects ?? {}).map(
+    ...Object.values(projects).map(
       (p) => p?.mcpServers
     )
   ];
@@ -666,7 +667,7 @@ function refreshClaudeConfigTokens(config6, token) {
       const auth = entry2?.headers?.Authorization;
       if (typeof auth !== "string" || !HSK_BEARER.test(auth)) continue;
       const next = `Bearer ${token}`;
-      if (auth === next) continue;
+      if (auth === next || !entry2?.headers) continue;
       entry2.headers.Authorization = next;
       changed.push(name);
     }
@@ -17784,6 +17785,78 @@ var init_exclusions = __esm({
         category: "operational",
         reason: "Operator annotation on a ledger row (why a CONCURRENTLY migration was applied outside a transaction, that a row was backfill-stamped). Written by us about our own schema changes, not by or about a tenant."
       },
+      // ── integrations ledger and the embedding batch queue, classified 2026-10-25 ──
+      // Both reached main unclassified; the ratchet caught them once CI could build.
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "id",
+        category: "operational",
+        reason: "The ledger key for one migration file (its group and name). Names our own schema change, never tenant data, and is how the ledger refuses to apply a file twice."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "migration_path",
+        category: "operational",
+        reason: "The repository path of the applied migration file. Ours, not a tenant's, and SOC 2 CC8.1 evidence that must stay readable."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "migration_group",
+        category: "operational",
+        reason: "The migrations/<group> directory a file belongs to: a fixed vocabulary of our own schema areas."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "connection_kind",
+        category: "operational",
+        reason: "Which role applied the file, app or admin (a CHECK-constrained vocabulary). Audit evidence about our own deploys."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "checksum_sha256",
+        category: "operational",
+        reason: "The file's SHA-256, compared on every run to catch a migration edited after it was applied. A hash of our own source; encrypting it would break that comparison."
+      },
+      {
+        database: "haansi_integrations_prod",
+        table: "schema_migrations",
+        column: "applied_by",
+        category: "operational",
+        reason: "The database role that applied the migration (DEFAULT current_user), such as haansi_migrator. Names our deploy role, not a person or a tenant, and is audit evidence."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "embedding_queue",
+        column: "target_table",
+        category: "structural",
+        reason: "Which intelligence table a queued row points at (knowledge_artifacts, exchange_posts). A fixed vocabulary of our own table names; the queue holds pointers only and the embed text never rests here."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "embedding_batch_jobs",
+        column: "provider_job_id",
+        category: "operational",
+        reason: "The embedding provider's id for a submitted batch, used to poll and collect it. Issued for our request; no tenant content (the table has no organization_id by design)."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "embedding_batch_jobs",
+        column: "input_file_id",
+        category: "operational",
+        reason: "The provider's id for the uploaded batch input file: an opaque handle. The file's content is never stored here."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "embedding_batch_jobs",
+        column: "model",
+        category: "not-personal",
+        reason: "The embedding model a batch ran on, a model name we choose. Kept readable so a batch's vectors can be matched to the model that produced them."
+      },
       {
         database: "haansi_integrations_prod",
         table: "source_accounts",
@@ -18001,6 +18074,20 @@ var init_exclusions = __esm({
         category: "operational",
         reason: "A nine-value CHECK-constrained enum (created, commented, reviewed, \u2026) copied from the canonical activity. No personal data."
       },
+      {
+        database: "haansi_intelligence_prod",
+        table: "mining_initial_loads",
+        column: "state",
+        category: "operational",
+        reason: "Closed CHECK vocabulary (holding, released) for the initial-load hold (object-graph/135). No content or personal data."
+      },
+      {
+        database: "haansi_intelligence_prod",
+        table: "mining_initial_loads",
+        column: "reason",
+        category: "operational",
+        reason: "Closed CHECK vocabulary for why the initial-load hold is held or released (initial_sync_pending, sessions_loading, ready, \u2026). No content or personal data."
+      },
       {
         database: "haansi_intelligence_prod",
         table: "organization_mining_config",
@@ -18879,7 +18966,414 @@ var init_exclusions = __esm({
         column: "event",
         category: "operational",
         reason: "Closed CHECK vocabulary (loaded, resource_loaded, synced, applied, helped, not_helped)."
-      }
+      },
+      ...exchangeExclusions(INTEL, "change_outcomes", {
+        repository: [
+          "not-personal",
+          "An `owner/repo` name, the key the ledger groups and joins on; plaintext in objects.attributes.repository for the same reason."
+        ],
+        head_sha: [
+          "join-key",
+          "A commit hash, matched by equality against CI runs and commits."
+        ],
+        merge_commit_sha: [
+          "join-key",
+          "A commit hash, matched by equality against reverts and commits."
+        ],
+        head_ref: [
+          "not-personal",
+          "The PR's head branch name; plaintext in objects.attributes.branch_name and in coding_session_change_links.branch."
+        ],
+        ci_status: [
+          "operational",
+          "Closed CHECK vocabulary (passed, failed, pending, none)."
+        ],
+        main_ci_status: [
+          "operational",
+          "Closed CHECK vocabulary (passed, failed, pending, none)."
+        ],
+        reverted_by: [
+          "join-key",
+          "A canonical object id (github:<repo>#<n> or github:commit:<sha>), never text."
+        ],
+        fix_forward_by: [
+          "join-key",
+          "A canonical object id (github:<repo>#<n>), never text."
+        ],
+        survival_14d: [
+          "operational",
+          "Closed CHECK vocabulary (held, failed, pending)."
+        ],
+        survival_30d: [
+          "operational",
+          "Closed CHECK vocabulary (held, failed, pending)."
+        ],
+        agent_tool: [
+          "not-personal",
+          "Names a coding agent product from a fixed list in the attribution code."
+        ],
+        agent_model: [
+          "not-personal",
+          "Names a model, read from an agent's commit trailer."
+        ],
+        attribution_method: [
+          "operational",
+          "Closed CHECK vocabulary (session, trailer, pr_metadata)."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "workstream_attempts", {
+        process_id: [
+          "join-key",
+          "The workstream's process_registry.process_id, joined by equality."
+        ],
+        repository: [
+          "not-personal",
+          "An `owner/repo` name; plaintext in change_outcomes.repository."
+        ],
+        result: [
+          "operational",
+          "Closed CHECK vocabulary (failed, held, open, superseded)."
+        ],
+        failure_signals: [
+          "operational",
+          "Closed CHECK vocabulary (ci_failed, main_ci_failed, reverted, closed_unmerged)."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "problem_families", {
+        status: [
+          "operational",
+          "Closed CHECK vocabulary (active, dissolved, merged)."
+        ],
+        tier: ["operational", "Closed CHECK vocabulary (recurring, playbook)."],
+        seed_process_id: [
+          "join-key",
+          "The seed workstream's process_registry.process_id, joined by equality."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "problem_family_feedback", {
+        action: [
+          "operational",
+          "Closed CHECK vocabulary (rename, merge, split, remove_member)."
+        ],
+        process_ids: [
+          "join-key",
+          "Workstream process ids a correction moved, joined by equality."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "family_matches", {
+        source: [
+          "operational",
+          "Closed CHECK vocabulary (task, ci_failure, alert)."
+        ],
+        source_ref: [
+          "join-key",
+          "owner/repo#n of a failing PR or an incident id; never task text."
+        ],
+        signals: [
+          "operational",
+          "Three numeric match signals (text, area, signature); no content."
+        ],
+        arm: ["operational", "Closed CHECK vocabulary (served, control)."],
+        session_id: [
+          "join-key",
+          "The coding session's id, joined by equality to coding_session_solutions."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "coding_session_link_rejections", {
+        session_id: [
+          "join-key",
+          "The coding session's id, joined by equality to its change links."
+        ],
+        repository: [
+          "not-personal",
+          "An owner/repo name, matched to change links by equality; plaintext in coding_session_change_links.repository."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "playbook_rollouts", {
+        status: [
+          "operational",
+          "Closed CHECK vocabulary (running, promoted, rolled_back)."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "workstream_decisions", {
+        process_id: [
+          "join-key",
+          "The workstream's process_registry.process_id, joined by equality."
+        ],
+        trigger: [
+          "operational",
+          "Closed CHECK vocabulary (concluded, concluding_event)."
+        ],
+        status: [
+          "operational",
+          "Closed CHECK vocabulary (draft, confirmed, dismissed)."
+        ],
+        outcome: [
+          "operational",
+          "Closed CHECK vocabulary (held, reversed, revisited)."
+        ],
+        change_keys: [
+          "join-key",
+          "owner/repo#n of the workstream's PRs, as in workstream_attempts."
+        ],
+        model: ["operational", "The model name that drafted it."],
+        prompt_tag: ["operational", "The prompt version that drafted it."]
+      }),
+      ...exchangeExclusions(INTEL, "workstream_decision_checks", {
+        process_id: [
+          "join-key",
+          "The workstream's process_registry.process_id, joined by equality."
+        ],
+        trigger: [
+          "operational",
+          "Closed CHECK vocabulary (concluded, concluding_event)."
+        ],
+        result: ["operational", "Closed CHECK vocabulary (none, invalid)."]
+      }),
+      ...exchangeExclusions(INTEL, "coding_session_haansi_usage", {
+        session_id: [
+          "join-key",
+          "The coding session's id, as in coding_session_setups, joined by equality."
+        ],
+        inputs: [
+          "not-personal",
+          "Counts of Haansi MCP calls per input type, and Haansi's own tool names."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "readiness_snapshots", {
+        baseline: [
+          "not-personal",
+          "Counts by month, top-level code area (repo paths) and workstream category."
+        ],
+        failure_signatures: [
+          "not-personal",
+          "Counts by Actions job and step name, from CI config."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "replay_results", {
+        process_id: [
+          "join-key",
+          "The replayed workstream's process_registry.process_id, joined by equality."
+        ],
+        arm: ["operational", "Closed CHECK vocabulary (baseline, haansi)."],
+        agent: ["operational", "The agent CLI's name, e.g. claude-code."],
+        model: ["operational", "The model name the replay ran with."],
+        run_ref: ["not-personal", "A link to the customer's CI run."]
+      }),
+      ...exchangeExclusions(INTEL, "replay_tasks", {
+        process_id: [
+          "join-key",
+          "The member workstream's process_registry.process_id, joined by equality."
+        ],
+        repository: [
+          "join-key",
+          "owner/repo of the workstream's PRs, as in workstream_attempts."
+        ],
+        base_sha: ["not-personal", "A commit SHA."],
+        target_sha: ["not-personal", "A commit SHA."],
+        checks: [
+          "not-personal",
+          "Actions workflow names from CI config that passed on the fix."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "problem_family_members", {
+        process_id: [
+          "join-key",
+          "A member workstream's process_registry.process_id, joined by equality."
+        ],
+        role: ["operational", "Closed CHECK vocabulary (smooth, rough, other)."],
+        areas: [
+          "not-personal",
+          "Repository directories the member's held PRs changed; the same class as changed paths' directories shown on the Families view."
+        ],
+        signatures: [
+          "not-personal",
+          'CI job and step names ("job \u203A step"), normalized; no log text.'
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "workstream_root_causes", {
+        process_id: [
+          "join-key",
+          "The workstream's process_registry.process_id, joined by equality."
+        ],
+        confidence: ["operational", "Closed CHECK vocabulary (high, medium, low)."],
+        input_hash: ["not-personal", "A SHA-256 of the inputs; no content."],
+        input_keys: [
+          "not-personal",
+          "owner/repo#n keys of the PRs the statement was written from."
+        ],
+        model: ["not-personal", "The model name that wrote the statement."],
+        prompt_tag: ["operational", "The prompt version tag."]
+      }),
+      ...exchangeExclusions(INTEL, "problem_family_findings", {
+        findings: [
+          "operational",
+          "Setup factor labels (action steps, skill names, agent, model, effort, instruction-file path and hash prefix) and pair counts, copied from coding_session_setups, which is itself plaintext; read only by viewers who can see every author in author_ids."
+        ],
+        author_ids: [
+          "join-key",
+          "organization_users ids whose sessions the findings drew on, compared with the viewer's visible authors."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "pull_request_checks", {
+        repository: [
+          "join-key",
+          "owner/repo of the PR, joined by equality to workstream_attempts.repository."
+        ],
+        checks: [
+          "not-personal",
+          "Actions workflow names from the repository's CI config, with closed status/conclusion values and run counts; no logs or output."
+        ],
+        failed: [
+          "not-personal",
+          'Normalized "job \u203A step" names from CI config, the same signatures problem families compare; no logs or output.'
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "attempt_rule_configs", {
+        config: [
+          "operational",
+          "Numeric rule settings per workstream category; no content."
+        ],
+        created_by: [
+          "operational",
+          "Closed CHECK vocabulary (tuning, platform_admin, defaults)."
+        ],
+        reason: [
+          "operational",
+          "Generated text naming the settings a version changed and the label counts behind it."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "attempt_rule_evaluations", {
+        config: [
+          "operational",
+          "The numeric rule settings the run scored; no content."
+        ],
+        metrics: ["operational", "Per-category label and hit counts; no content."],
+        decision: [
+          "operational",
+          "Closed CHECK vocabulary (kept, stepped, too_few_labels)."
+        ],
+        changes: ["operational", "The settings a run stepped, as numbers."]
+      }),
+      ...exchangeExclusions(INTEL, "coding_session_solutions", {
+        segment_branch: [
+          "not-personal",
+          "A git branch name, matched to commit links' branch by equality; plaintext like coding_session_change_links.branch."
+        ],
+        outcome: [
+          "operational",
+          "Closed CHECK vocabulary (held, failed) stamped by the outcome ledger from the solution's linked PRs."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "coding_session_setups", {
+        repository: [
+          "join-key",
+          "owner/repo from the session's git remote, joined to PRs by equality."
+        ],
+        branch: [
+          "join-key",
+          "The git branch the session uploaded on, joined to a PR's head branch; plaintext like coding_session_change_links.branch."
+        ],
+        session_id: [
+          "join-key",
+          "The coding session's id, joined by equality to coding_session_solutions."
+        ],
+        agent_tool: [
+          "operational",
+          "Names a coding agent product (claude-code, codex) from the parser."
+        ],
+        models: ["not-personal", "Model names the agent's transcript recorded."],
+        effort: ["operational", "A reasoning-effort level such as high or medium."],
+        git_commit: [
+          "not-personal",
+          "A commit SHA; plaintext in change_outcomes and coding_session_change_links."
+        ],
+        instructions: [
+          "not-personal",
+          "Instruction-file paths with the home directory stripped, a closed kind and a content hash; no file content."
+        ],
+        skills: [
+          "not-personal",
+          "Skill names the agent loaded and Haansi skill/revision ids; no skill content."
+        ],
+        context: [
+          "not-personal",
+          "Counts of reads, searches, web fetches and subagents, and MCP tool names; no paths, queries or content."
+        ],
+        prompt_turn_uuid: [
+          "join-key",
+          "A transcript message uuid: the prompt by reference, never its text."
+        ],
+        prompt_fingerprint: [
+          "not-personal",
+          "A 64-bit SimHash of the prompt's words; the text cannot be recovered from it."
+        ],
+        actions: ["operational", "Closed CHECK vocabulary of action step types."]
+      }),
+      ...exchangeExclusions(INTEL, "workstream_attempt_labels", {
+        process_id: [
+          "join-key",
+          "The workstream's process_registry.process_id, joined by equality."
+        ],
+        repository: [
+          "not-personal",
+          "An `owner/repo` name; plaintext in workstream_attempts.repository."
+        ],
+        label: [
+          "operational",
+          "Closed CHECK vocabulary (right_fix, wrong_fix, fixed_by, not_failure, not_replaced, cleared)."
+        ],
+        rule_result: [
+          "operational",
+          "The rule's result when labeled: workstream_attempts.result vocabulary."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "coding_session_lineage", {
+        session_id: [
+          "join-key",
+          "The coding session's id, joined by equality to coding_session_solutions."
+        ],
+        root_turn_uuid: [
+          "join-key",
+          "A transcript message uuid, matched by equality to find resumed sessions."
+        ],
+        last_turn_uuid: [
+          "join-key",
+          "A transcript message uuid, looked up in a resumed session's messages."
+        ],
+        replaced_by_session_id: [
+          "join-key",
+          "The replacing coding session's id, joined by equality when superseding."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "coding_session_change_scans", {
+        session_id: [
+          "join-key",
+          "The coding session's id, joined by equality to coding_session_solutions."
+        ]
+      }),
+      ...exchangeExclusions(INTEL, "coding_session_change_links", {
+        session_id: [
+          "join-key",
+          "The coding session's id, joined by equality to coding_session_solutions."
+        ],
+        kind: [
+          "operational",
+          "Closed CHECK vocabulary (commit, pr_created, pr_merged)."
+        ],
+        commit_sha: [
+          "join-key",
+          "A commit hash, matched by prefix against PR commits."
+        ],
+        branch: [
+          "not-personal",
+          "A git branch name, matched against PR head branches; plaintext in objects.attributes.branch_name for the same reason."
+        ],
+        repository: [
+          "not-personal",
+          "An `owner/repo` name, the key links are resolved within; plaintext in change_outcomes.repository."
+        ]
+      })
     ];
   }
 });
@@ -25867,7 +26361,132 @@ var init_table_registry = __esm({
         "artifact_cluster_workstreams",
         "direct",
         { scopingColumn: "organization_id" }
-      )
+      ),
+      // Outcome ledger v0: derived per merged PR from the org's source_events by
+      // the service-pipeline outcome-ledger tick, on the org's userdata pool.
+      entry("intelligence", INTELLIGENCE_DB, "change_outcomes", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Attempt chains: each mined workstream's PRs, failures and fix-forwards.
+      entry("intelligence", INTELLIGENCE_DB, "workstream_attempts", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Problem families: resolved workstreams grouped by problem, and runs.
+      entry("intelligence", INTELLIGENCE_DB, "problem_families", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "problem_family_members", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "problem_family_runs", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Matches of new work to a family (playbooks plan §4.8).
+      entry("intelligence", INTELLIGENCE_DB, "family_matches", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Window links a session's author rejected (sessions plan §3.1).
+      entry(
+        "intelligence",
+        INTELLIGENCE_DB,
+        "coding_session_link_rejections",
+        "direct",
+        {
+          scopingColumn: "organization_id"
+        }
+      ),
+      // Rollouts of a family's playbook revision (playbooks plan phase 6).
+      entry("intelligence", INTELLIGENCE_DB, "playbook_rollouts", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Decisions drafted when a workstream concludes (blueprint, Decisions).
+      entry("intelligence", INTELLIGENCE_DB, "workstream_decisions", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Workstreams the ledger found to have no decision (never shown).
+      entry(
+        "intelligence",
+        INTELLIGENCE_DB,
+        "workstream_decision_checks",
+        "direct",
+        {
+          scopingColumn: "organization_id"
+        }
+      ),
+      // What Haansi gave each coding session (readiness restructure plan §4.6).
+      entry(
+        "intelligence",
+        INTELLIGENCE_DB,
+        "coding_session_haansi_usage",
+        "direct",
+        {
+          scopingColumn: "organization_id"
+        }
+      ),
+      // The readiness report's baseline (readiness restructure plan §4.1).
+      entry("intelligence", INTELLIGENCE_DB, "readiness_snapshots", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Replay results reported from the customer's CI (readiness plan §4.6).
+      entry("intelligence", INTELLIGENCE_DB, "replay_results", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // Replay tasks cut from family members (playbooks plan §4.7).
+      entry("intelligence", INTELLIGENCE_DB, "replay_tasks", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "problem_family_feedback", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "workstream_root_causes", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "problem_family_findings", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // The checks that ran on each PR's head commit.
+      entry("intelligence", INTELLIGENCE_DB, "pull_request_checks", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // The attempt rule's per-org settings (versioned) and its scoring runs.
+      entry("intelligence", INTELLIGENCE_DB, "attempt_rule_configs", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      entry("intelligence", INTELLIGENCE_DB, "attempt_rule_evaluations", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // What each coding session ran with (agent, instructions, skills, actions).
+      entry("intelligence", INTELLIGENCE_DB, "coding_session_setups", "direct", {
+        scopingColumn: "organization_id"
+      }),
+      // People's labels on attempt chains; override the rule, kept for evaluation.
+      entry(
+        "intelligence",
+        INTELLIGENCE_DB,
+        "workstream_attempt_labels",
+        "direct",
+        { scopingColumn: "organization_id" }
+      ),
+      // Commits and PRs named in a coding session's transcript, recorded at mining
+      // time beside the session's solutions.
+      entry(
+        "intelligence",
+        INTELLIGENCE_DB,
+        "coding_session_change_links",
+        "direct",
+        { scopingColumn: "organization_id" }
+      ),
+      entry(
+        "intelligence",
+        INTELLIGENCE_DB,
+        "coding_session_change_scans",
+        "direct",
+        { scopingColumn: "organization_id" }
+      ),
+      // Resumed-session lineage: which session file replaced which.
+      entry("intelligence", INTELLIGENCE_DB, "coding_session_lineage", "direct", {
+        scopingColumn: "organization_id"
+      })
     ];
     INTEGRATIONS_DB = "haansi_integrations_prod";
     integrationTables = [
@@ -76695,10 +77314,10 @@ var require_view = __commonJS({
     var debug = require_src()("express:view");
     var path2 = require("node:path");
     var fs = require("node:fs");
-    var dirname4 = path2.dirname;
+    var dirname5 = path2.dirname;
     var basename4 = path2.basename;
     var extname = path2.extname;
-    var join15 = path2.join;
+    var join16 = path2.join;
     var resolve5 = path2.resolve;
     module2.exports = View;
     function View(name, options) {
@@ -76734,7 +77353,7 @@ var require_view = __commonJS({
       for (var i = 0; i < roots.length && !path3; i++) {
         var root = roots[i];
         var loc = resolve5(root, name);
-        var dir = dirname4(loc);
+        var dir = dirname5(loc);
         var file2 = basename4(loc);
         path3 = this.resolve(dir, file2);
       }
@@ -76760,12 +77379,12 @@ var require_view = __commonJS({
     };
     View.prototype.resolve = function resolve6(dir, file2) {
       var ext = this.ext;
-      var path3 = join15(dir, file2);
+      var path3 = join16(dir, file2);
       var stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
       }
-      path3 = join15(dir, basename4(file2, ext), "index" + ext);
+      path3 = join16(dir, basename4(file2, ext), "index" + ext);
       stat = tryStat(path3);
       if (stat && stat.isFile()) {
         return path3;
@@ -80410,7 +81029,7 @@ var require_send = __commonJS({
     var Stream = require("stream");
     var util2 = require("util");
     var extname = path2.extname;
-    var join15 = path2.join;
+    var join16 = path2.join;
     var normalize = path2.normalize;
     var resolve5 = path2.resolve;
     var sep2 = path2.sep;
@@ -80582,7 +81201,7 @@ var require_send = __commonJS({
           return res;
         }
         parts = path3.split(sep2);
-        path3 = normalize(join15(root, path3));
+        path3 = normalize(join16(root, path3));
       } else {
         if (UP_PATH_REGEXP.test(path3)) {
           debug('malicious path "%s"', path3);
@@ -80715,7 +81334,7 @@ var require_send = __commonJS({
           if (err2) return self.onStatError(err2);
           return self.error(404);
         }
-        var p = join15(path3, self._index[i]);
+        var p = join16(path3, self._index[i]);
         debug('stat "%s"', p);
         fs.stat(p, function(err3, stat) {
           if (err3) return next(err3);
@@ -84426,6 +85045,363 @@ var init_skills = __esm({
   }
 });
 
+// src/commands/replay.ts
+var replay_exports = {};
+__export(replay_exports, {
+  githubRunRef: () => githubRunRef,
+  parseReplayArgs: () => parseReplayArgs,
+  replay: () => replay,
+  replayArm: () => replayArm,
+  replayPrompt: () => replayPrompt,
+  repositoryFromRemote: () => repositoryFromRemote,
+  runCommand: () => runCommand,
+  runReplays: () => runReplays,
+  safeTestFile: () => safeTestFile,
+  skipReason: () => skipReason
+});
+function parseReplayArgs(argv) {
+  const options = {
+    familyId: "",
+    agentCmd: "",
+    testCmd: "",
+    attempts: 3,
+    arms: [...ARMS],
+    limit: null,
+    cutoff: null,
+    timeoutMs: 30 * 6e4,
+    agentName: null,
+    model: null,
+    runRef: githubRunRef(process.env),
+    dryRun: false
+  };
+  let sub;
+  const errors = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => argv[++i] ?? "";
+    if (a === "--family") options.familyId = next();
+    else if (a === "--agent-cmd") options.agentCmd = next();
+    else if (a === "--test-cmd") options.testCmd = next();
+    else if (a === "--attempts") options.attempts = Number(next());
+    else if (a === "--limit") options.limit = Number(next());
+    else if (a === "--cutoff") options.cutoff = next();
+    else if (a === "--timeout-min") options.timeoutMs = Number(next()) * 6e4;
+    else if (a === "--agent-name") options.agentName = next();
+    else if (a === "--model") options.model = next();
+    else if (a === "--run-ref") options.runRef = next();
+    else if (a === "--dry-run") options.dryRun = true;
+    else if (a === "--arms")
+      options.arms = next().split(",").map((s) => s.trim()).filter(Boolean);
+    else if (!sub && !a.startsWith("-")) sub = a;
+    else errors.push(`Unknown option: ${a}`);
+  }
+  if (!/^[0-9a-f-]{36}$/i.test(options.familyId))
+    errors.push("--family <id> is required (the family's id).");
+  if (!options.agentCmd) errors.push("--agent-cmd is required.");
+  if (!options.testCmd) errors.push("--test-cmd is required.");
+  if (!Number.isInteger(options.attempts) || options.attempts < 1 || options.attempts > 20)
+    errors.push("--attempts must be 1 to 20.");
+  if (options.limit !== null && (!Number.isInteger(options.limit) || options.limit < 1))
+    errors.push("--limit must be a positive whole number.");
+  if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)
+    errors.push("--timeout-min must be a positive number.");
+  if (options.arms.length === 0 || options.arms.some((a) => !ARMS.includes(a)))
+    errors.push("--arms must list baseline and/or haansi.");
+  return { sub, options, errors };
+}
+function githubRunRef(env) {
+  const { GITHUB_SERVER_URL, GITHUB_REPOSITORY, GITHUB_RUN_ID } = env;
+  if (!GITHUB_SERVER_URL?.startsWith("https://") || !GITHUB_REPOSITORY || !GITHUB_RUN_ID)
+    return null;
+  return `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`;
+}
+function repositoryFromRemote(remote) {
+  const m = /[:/]([^/:\s]+\/[^/\s]+?)(?:\.git)?\/?\s*$/.exec(remote.trim());
+  return m ? m[1].toLowerCase() : null;
+}
+function safeTestFile(path2) {
+  return path2.length > 0 && !path2.startsWith("/") && !path2.startsWith("-") && !path2.split("/").includes("..") && !/[\u0000-\u001f]/.test(path2);
+}
+function skipReason(task, repository) {
+  if (!repository || task.repository.toLowerCase() !== repository)
+    return `in ${task.repository}, not this repository`;
+  if (!task.baseSha || !SHA.test(task.baseSha)) return "no starting commit";
+  if (!task.targetSha || !SHA.test(task.targetSha)) return "no fix commit";
+  if (task.testFiles.length === 0) return "the fix changed no test file";
+  if (!task.testFiles.every(safeTestFile)) return "a test path is not usable";
+  return null;
+}
+function replayPrompt(task, arm, feedback) {
+  const context = task.context.length ? task.context.map((c) => `- ${c}`).join("\n") : "- (No record of the task before the first attempt was captured.)";
+  return [
+    `# ${task.name ?? "A task in this repository"}`,
+    "",
+    "Solve the problem these describe, in this repository as it is now:",
+    "",
+    context,
+    "",
+    ...arm === "haansi" ? [
+      "Your team's playbook for this kind of problem is in .haansi-replay/playbook.md. Read it first.",
+      ""
+    ] : [],
+    ...feedback ? [
+      "Your previous attempt did not pass the tests. Their output ends with:",
+      "",
+      "```",
+      feedback,
+      "```",
+      ""
+    ] : [],
+    "Do not look at later commits or other branches."
+  ].join("\n");
+}
+async function ensureCommit(deps, sha) {
+  if ((await deps.git(["cat-file", "-e", `${sha}^{commit}`], deps.repoDir)).code === 0)
+    return true;
+  return (await deps.git(["fetch", "--quiet", "origin", sha], deps.repoDir)).code === 0;
+}
+async function replayArm(deps, options, task, arm, playbook) {
+  const started = deps.now();
+  const dir = (0, import_node_path9.join)(
+    deps.workDir(),
+    `${task.processId.replace(/[^a-zA-Z0-9_-]/g, "")}-${arm}`
+  );
+  const files = task.testFiles;
+  const add = await deps.git(
+    ["worktree", "add", "--detach", dir, task.baseSha],
+    deps.repoDir
+  );
+  if (add.code !== 0) throw new Error(`could not check out ${task.baseSha}`);
+  try {
+    const promptFile = (0, import_node_path9.join)(dir, ".haansi-replay", "prompt.md");
+    if (arm === "haansi" && playbook)
+      deps.writeFile(
+        (0, import_node_path9.join)(dir, ".haansi-replay", "playbook.md"),
+        playbook.skillMd
+      );
+    let feedback = null;
+    for (let attempt = 1; attempt <= options.attempts; attempt++) {
+      const prompt2 = replayPrompt(task, arm, feedback);
+      deps.writeFile(promptFile, prompt2);
+      await deps.shell(
+        options.agentCmd,
+        dir,
+        { HAANSI_REPLAY_PROMPT: prompt2, HAANSI_REPLAY_PROMPT_FILE: promptFile },
+        options.timeoutMs
+      );
+      const own = new Map(files.map((f) => [f, deps.readFile((0, import_node_path9.join)(dir, f))]));
+      const checkout = await deps.git(
+        ["checkout", task.targetSha, "--", ...files],
+        dir
+      );
+      if (checkout.code !== 0)
+        throw new Error("could not check out the fix's tests");
+      const test = await deps.shell(
+        options.testCmd,
+        dir,
+        { HAANSI_REPLAY_TEST_FILES: files.join(" ") },
+        options.timeoutMs
+      );
+      if (test.code === 0) {
+        return {
+          processId: task.processId,
+          arm,
+          passed: true,
+          attempts: attempt,
+          maxAttempts: options.attempts,
+          durationMs: deps.now() - started,
+          revisionId: arm === "haansi" ? playbook?.revisionId ?? null : null
+        };
+      }
+      for (const [file2, content] of own) {
+        if (content === null) deps.removeFile((0, import_node_path9.join)(dir, file2));
+        else deps.writeFile((0, import_node_path9.join)(dir, file2), content);
+      }
+      feedback = test.output.slice(-FEEDBACK_CHARS);
+    }
+    return {
+      processId: task.processId,
+      arm,
+      passed: false,
+      attempts: options.attempts,
+      maxAttempts: options.attempts,
+      durationMs: deps.now() - started,
+      revisionId: arm === "haansi" ? playbook?.revisionId ?? null : null
+    };
+  } finally {
+    await deps.git(["worktree", "remove", "--force", dir], deps.repoDir);
+    deps.removeDir(dir);
+  }
+}
+async function runReplays(options, deps) {
+  const remote = await deps.git(["remote", "get-url", "origin"], deps.repoDir);
+  const repository = remote.code === 0 ? repositoryFromRemote(remote.output) : null;
+  const tasks = await deps.getTasks(options.familyId, options.cutoff);
+  let arms = options.arms;
+  let playbook = null;
+  if (arms.includes("haansi")) {
+    playbook = await deps.getPlaybook(options.familyId);
+    if (!playbook) {
+      deps.log(
+        "The family has no published playbook you can read: running the baseline arm only."
+      );
+      arms = arms.filter((a) => a !== "haansi");
+    }
+  }
+  const runnable = [];
+  let skipped = 0;
+  for (const task of tasks) {
+    const reason = skipReason(task, repository);
+    if (reason) {
+      skipped += 1;
+      deps.log(`skip ${task.name ?? task.processId}: ${reason}`);
+    } else runnable.push(task);
+  }
+  const chosen = options.limit ? runnable.slice(0, options.limit) : runnable;
+  const results = [];
+  for (const task of chosen) {
+    if (!await ensureCommit(deps, task.baseSha) || !await ensureCommit(deps, task.targetSha)) {
+      skipped += 1;
+      deps.log(
+        `skip ${task.name ?? task.processId}: its commits are not reachable from origin`
+      );
+      continue;
+    }
+    for (const arm of arms) {
+      try {
+        const result = await replayArm(deps, options, task, arm, playbook);
+        results.push(result);
+        deps.log(
+          `${result.passed ? "pass" : "fail"} ${arm.padEnd(8)} ${task.name ?? task.processId} (${result.attempts}/${result.maxAttempts} attempts)`
+        );
+      } catch (err2) {
+        deps.log(
+          `error ${arm} ${task.name ?? task.processId}: ${err2 instanceof Error ? err2.message : String(err2)}`
+        );
+      }
+    }
+  }
+  if (options.dryRun || results.length === 0) {
+    return { results, skipped, recorded: null };
+  }
+  const reported = await deps.report(options.familyId, {
+    agent: options.agentName,
+    model: options.model,
+    runRef: options.runRef,
+    results
+  });
+  if (reported.refused.length)
+    deps.log(
+      `Haansi did not record ${reported.refused.length} task(s) it no longer lists for this family.`
+    );
+  return { results, skipped, recorded: reported.recorded };
+}
+function runCommand(file2, args, cwd, env, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const child = (0, import_node_child_process4.spawn)(file2, args, {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    const keep = (chunk) => {
+      output = (output + chunk.toString()).slice(-2e5);
+    };
+    child.stdout.on("data", keep);
+    child.stderr.on("data", keep);
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolvePromise({ code: code ?? 1, output });
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolvePromise({ code: 1, output });
+    });
+  });
+}
+async function replay(argv) {
+  const { sub, options, errors } = parseReplayArgs(argv);
+  if (sub !== "run" || errors.length) {
+    for (const e of sub === "run" ? errors : []) console.error(e);
+    console.log(USAGE);
+    if (sub === "run") process.exitCode = 1;
+    return;
+  }
+  const token = resolveToken5();
+  const apiUrl2 = apiUrl();
+  const work = (0, import_node_fs10.mkdtempSync)((0, import_node_path9.join)((0, import_node_os9.tmpdir)(), "haansi-replay-"));
+  try {
+    const { results, skipped, recorded } = await runReplays(options, {
+      getTasks: async (familyId, cutoff) => (await apiGet3(
+        `/memory/processes/families/${familyId}/replay-tasks${cutoff ? `?cutoff=${encodeURIComponent(cutoff)}` : ""}`,
+        token,
+        apiUrl2
+      )).replay,
+      getPlaybook: async (familyId) => (await apiGet3(
+        `/memory/skills/families/${familyId}/playbook`,
+        token,
+        apiUrl2
+      ).catch(() => ({ data: { playbook: null } }))).data.playbook,
+      report: async (familyId, body) => await apiPost2(
+        `/memory/processes/families/${familyId}/replay-results`,
+        body,
+        token,
+        apiUrl2
+      ),
+      git: (args, cwd) => runCommand("git", args, cwd, {}, 10 * 6e4),
+      shell: (command2, cwd, env, timeoutMs) => runCommand("sh", ["-c", command2], cwd, env, timeoutMs),
+      repoDir: process.cwd(),
+      workDir: () => work,
+      writeFile: (path2, content) => {
+        (0, import_node_fs10.mkdirSync)((0, import_node_path9.dirname)(path2), { recursive: true });
+        (0, import_node_fs10.writeFileSync)(path2, content);
+      },
+      readFile: (path2) => (0, import_node_fs10.existsSync)(path2) ? (0, import_node_fs10.readFileSync)(path2, "utf-8") : null,
+      removeFile: (path2) => (0, import_node_fs10.rmSync)(path2, { force: true }),
+      removeDir: (path2) => (0, import_node_fs10.rmSync)(path2, { recursive: true, force: true }),
+      now: () => Date.now(),
+      log: (line) => console.log(line)
+    });
+    const passed = (arm) => results.filter((r) => r.arm === arm && r.passed).length;
+    const ran = (arm) => results.filter((r) => r.arm === arm).length;
+    console.log(
+      `
+Baseline: ${passed("baseline")}/${ran("baseline")} passed \xB7 With Haansi: ${passed("haansi")}/${ran("haansi")} passed \xB7 ${skipped} skipped`
+    );
+    console.log(
+      recorded === null ? options.dryRun ? "Dry run: nothing reported." : "Nothing to report." : `Reported ${recorded} result(s) to Haansi.`
+    );
+  } finally {
+    (0, import_node_fs10.rmSync)(work, { recursive: true, force: true });
+  }
+}
+var import_node_child_process4, import_node_fs10, import_node_os9, import_node_path9, SHA, ARMS, FEEDBACK_CHARS, USAGE;
+var init_replay = __esm({
+  "src/commands/replay.ts"() {
+    "use strict";
+    import_node_child_process4 = require("node:child_process");
+    import_node_fs10 = require("node:fs");
+    import_node_os9 = require("node:os");
+    import_node_path9 = require("node:path");
+    init_paths();
+    init_api2();
+    SHA = /^[0-9a-f]{7,40}$/i;
+    ARMS = ["baseline", "haansi"];
+    FEEDBACK_CHARS = 6e3;
+    USAGE = `Usage: haansi replay run --family <id> --agent-cmd "<cmd>" --test-cmd "<cmd>"
+                         [--attempts 3] [--arms baseline,haansi] [--limit n]
+                         [--cutoff <date>] [--timeout-min 30]
+                         [--agent-name <name>] [--model <name>] [--run-ref <url>] [--dry-run]
+
+Run from a clone of the repository. Example (GitHub Actions):
+  haansi replay run --family "$FAMILY_ID" \\
+    --agent-cmd 'claude -p "$HAANSI_REPLAY_PROMPT" --permission-mode acceptEdits' \\
+    --test-cmd 'npx vitest run $HAANSI_REPLAY_TEST_FILES' \\
+    --agent-name claude-code --model claude-sonnet-5-5`;
+  }
+});
+
 // src/index.ts
 init_paths();
 var { version: VERSION } = require_package();
@@ -84598,6 +85574,11 @@ Active selection (${selection.source}): ${selection.agents.join(", ")}`
       await skills2(process.argv.slice(3));
       break;
     }
+    case "replay": {
+      const { replay: replay2 } = await Promise.resolve().then(() => (init_replay(), replay_exports));
+      await replay2(process.argv.slice(3));
+      break;
+    }
     case "digest": {
       const { digest: digest2, parseDigestRange: parseDigestRange2 } = await Promise.resolve().then(() => (init_digest(), digest_exports));
       await digest2(parseDigestRange2(process.argv.slice(3)));
@@ -84635,6 +85616,9 @@ Commands:
                              digest. [--date YYYY-MM-DD] [--workstream <id>]
   digest [--week|--month|--since YYYY-MM-DD]
                              Your weekly digest (default: the latest week)
+  replay run --family <id> --agent-cmd "<cmd>" --test-cmd "<cmd>"
+                             Replay a problem family's tasks in your CI, with and
+                             without its playbook, and report the results
   skills sync [--agent <sel>] [--project] [--dir <path>]
                              Copy your team's published skills into Claude Code / Codex
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haansi",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
   "bin": {
     "haansi": "./dist/haansi.js"