@dosu/cli 0.53.0-beta.7 → 0.53.0-beta.9

package/bin/dosu.js

@@ -5018,7 +5018,7 @@ function isNpxInvocation(channel = INSTALL_CHANNEL, env = process.env) {
 function getVersionString() {
   return `v${VERSION}`;
 }
-var VERSION = "0.53.0-beta.7", INSTALL_CHANNEL = "npm";
+var VERSION = "0.53.0-beta.9", INSTALL_CHANNEL = "npm";
 
 // src/debug/logger.ts
 import {
@@ -5156,7 +5156,7 @@ var init_logger = __esm(() => {
 });
 
 // src/client/contract.ts
-var CLI_CONTRACT_HASH = "79ec0bbacf70";
+var CLI_CONTRACT_HASH = "d7c6f0f0e8d0";
 
 // src/client/trpc.ts
 var exports_trpc = {};
@@ -10678,6 +10678,134 @@ var init_sync = __esm(() => {
   init_watermark();
 });
 
+// src/report/backfill.ts
+function noteTime2(at) {
+  const parsed = Date.parse(at ?? "");
+  return Number.isNaN(parsed) ? Number.NaN : parsed;
+}
+function correlateBackfill(input) {
+  const batches = new Map;
+  for (const e of input.ledger) {
+    const members = batches.get(e.at) ?? [];
+    members.push(e.session);
+    batches.set(e.at, members);
+  }
+  const batchTimes = [...batches.keys()].map((at) => ({ at, t: Date.parse(at) })).filter((b2) => !Number.isNaN(b2.t));
+  const sessionByKey = new Map(input.sessions.map((s) => [`${s.harness}/${s.id}`, s]));
+  const cyclesCache = new Map;
+  const cyclesFor = (session) => {
+    let cycles = cyclesCache.get(session.id);
+    if (!cycles) {
+      cycles = sessionCycles(sessionToDigest(session).turns);
+      cyclesCache.set(session.id, cycles);
+    }
+    return cycles;
+  };
+  const mappings = [];
+  let ambiguous = 0;
+  let noBatch = 0;
+  for (const note of input.notes) {
+    const time = noteTime2(note.at);
+    if (Number.isNaN(time)) {
+      noBatch += 1;
+      continue;
+    }
+    let batchAt;
+    let bestD = Number.POSITIVE_INFINITY;
+    for (const b2 of batchTimes) {
+      const d = Math.abs(b2.t - time);
+      if (d <= BATCH_TOLERANCE_MS && d < bestD) {
+        bestD = d;
+        batchAt = b2.at;
+      }
+    }
+    if (!batchAt) {
+      noBatch += 1;
+      continue;
+    }
+    const members = (batches.get(batchAt) ?? []).map((k) => sessionByKey.get(k)).filter((s) => s !== undefined);
+    if (members.length === 0) {
+      noBatch += 1;
+      continue;
+    }
+    const words = noteWords(note);
+    let best;
+    let second = 0;
+    for (const session of members) {
+      let score = 0;
+      for (const cycle of cyclesFor(session)) {
+        const s = cycleMatchScore(words, cycle.text);
+        if (s > score)
+          score = s;
+      }
+      if (!best || score > best.score) {
+        second = best?.score ?? 0;
+        best = { session, score };
+      } else if (score > second) {
+        second = score;
+      }
+    }
+    if (!best || best.score < MIN_SCORE || second > 0 && best.score < second * CLEAR_WIN_RATIO) {
+      ambiguous += 1;
+      continue;
+    }
+    mappings.push({ note_id: note.id, transcript_id: best.session.id });
+  }
+  return { mappings, ambiguous, noBatch };
+}
+var BATCH_TOLERANCE_MS, CLEAR_WIN_RATIO = 1.5, MIN_SCORE = 3;
+var init_backfill = __esm(() => {
+  init_digest();
+  init_notes();
+  BATCH_TOLERANCE_MS = 30 * 60 * 1000;
+});
+
+// src/report/backfill-run.ts
+var exports_backfill_run = {};
+__export(exports_backfill_run, {
+  runBackfill: () => runBackfill
+});
+async function defaultFetchUnattributed(cfg) {
+  const orgId = cfg.active_account?.target?.org_id;
+  if (!orgId || !cfg.active_account?.session.access_token) {
+    throw new Error("Not signed in. Run `dosu setup` to connect an account first.");
+  }
+  const { createTypedClient: createTypedClient2 } = await Promise.resolve().then(() => (init_trpc(), exports_trpc));
+  const client = createTypedClient2(cfg);
+  const { notes } = await client.notes.listMine.query({ org_id: orgId, limit: 500 });
+  return notes.filter((n2) => !n2.transcript_id).map((n2) => ({ id: n2.id, title: n2.title, content: n2.body, at: n2.created_at }));
+}
+async function defaultApply(cfg, mappings) {
+  const { createTypedClient: createTypedClient2 } = await Promise.resolve().then(() => (init_trpc(), exports_trpc));
+  const client = createTypedClient2(cfg);
+  let updated = 0;
+  for (let i2 = 0;i2 < mappings.length; i2 += MUTATION_CHUNK) {
+    const chunk = mappings.slice(i2, i2 + MUTATION_CHUNK);
+    const res = await client.notes.attributeTranscripts.mutate({ mappings: chunk });
+    updated += res.updated;
+  }
+  return updated;
+}
+async function runBackfill(deps = {}) {
+  const cfg = (deps.loadCfg ?? loadConfig)();
+  const notes = await (deps.fetchUnattributed ?? defaultFetchUnattributed)(cfg);
+  if (notes.length === 0) {
+    return { candidates: 0, mappings: [], ambiguous: 0, noBatch: 0, updated: 0 };
+  }
+  const ledger = (deps.ledger ?? (() => loadSyncState().mined_sessions ?? []))();
+  const sessions = (deps.scan ?? scanAgentSessions)();
+  const { mappings, ambiguous, noBatch } = correlateBackfill({ notes, ledger, sessions });
+  const updated = mappings.length > 0 ? await (deps.apply ?? defaultApply)(cfg, mappings) : 0;
+  return { candidates: notes.length, mappings, ambiguous, noBatch, updated };
+}
+var MUTATION_CHUNK = 500;
+var init_backfill_run = __esm(() => {
+  init_config();
+  init_scan();
+  init_watermark();
+  init_backfill();
+});
+
 // src/miner/config-dir.ts
 import { mkdtempSync, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
@@ -10850,7 +10978,7 @@ function buildMinerPrompt(sessions) {
 
 ${list}
 
-Read each session with read_session, decide what (if anything) is durable per your rules, dedupe against read_knowledge, then write the distilled notes with write_knowledge. When you are done, reply with a one-line summary: how many sessions you read and how many notes you wrote.`;
+Work through them ONE AT A TIME: read a single session with read_session, decide what (if anything) is durable per your rules, dedupe against read_knowledge, and write that session's notes with write_knowledge BEFORE moving on to the next session. Each note is attributed to the session you read just before writing it, so do not read the next session until you have written this one's notes. When you are done, reply with a one-line summary: how many sessions you read and how many notes you wrote.`;
 }
 
 // src/miner/prompt-core.ts
@@ -72798,7 +72926,8 @@ async function runMiner(options) {
   const abort = new AbortController;
   const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? DEFAULT_TIMEOUT_MS2);
   let notesWritten = 0;
-  let lastSessionId;
+  let currentSession;
+  const readsSinceWrite = new Set;
   let turns = 0;
   const env = buildMinerEnv({
     apiKey: options.apiKey,
@@ -72843,7 +72972,11 @@ async function runMiner(options) {
             };
           }
           if (toolName === `mcp__${SESSIONS_SERVER_NAME}__read_session`) {
-            lastSessionId = sessionIdFromReadInput(input2) ?? lastSessionId;
+            const id2 = sessionIdFromReadInput(input2);
+            if (id2) {
+              currentSession = id2;
+              readsSinceWrite.add(id2);
+            }
           }
           if (toolName === `mcp__${KNOWLEDGE_SERVER_NAME}__write_knowledge`) {
             if (notesWritten >= maxNotes) {
@@ -72852,10 +72985,20 @@ async function runMiner(options) {
                 message: `Note cap reached (${maxNotes} per run); stop writing and summarize.`
               };
             }
+            if (readsSinceWrite.size > 1) {
+              readsSinceWrite.clear();
+              currentSession = undefined;
+              return {
+                behavior: "deny",
+                message: "Write each session's notes right after reading THAT session, before reading the next. You have read multiple sessions without writing, so a note cannot be attributed to one. Re-read only the session this note is about, then write it."
+              };
+            }
             notesWritten += 1;
+            readsSinceWrite.clear();
+            const { transcript_id: _authoredByModel, ...clean } = input2;
             return {
               behavior: "allow",
-              updatedInput: lastSessionId ? { ...input2, transcript_id: lastSessionId } : input2
+              updatedInput: currentSession ? { ...clean, transcript_id: currentSession } : clean
             };
           }
           return { behavior: "allow", updatedInput: input2 };
@@ -73376,7 +73519,7 @@ var init_settings = __esm(() => {
 });
 
 // src/telemetry/debug-id.ts
-var BUNDLE_DEBUG_ID_PLACEHOLDER = "d438e963-a417-e96d-6475-6e2164756e21";
+var BUNDLE_DEBUG_ID_PLACEHOLDER = "971484cf-da0f-e0c4-6475-6e2164756e21";
 
 // src/telemetry/telemetry.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
@@ -82309,6 +82452,19 @@ ${results.length - opts.limit} more results not shown.`));
     }
     console.log(`Wrote ${path3}`);
   });
+  cmd.command("backfill-transcripts").description("One-shot: attribute pre-existing notes to the local sessions that produced them, so the report can show their traces").option("--json", "Output the result as JSON").action(async (opts) => {
+    const { runBackfill: runBackfill2 } = await Promise.resolve().then(() => (init_backfill_run(), exports_backfill_run));
+    const result = await runBackfill2();
+    if (opts.json) {
+      printResult(result, opts);
+      return;
+    }
+    if (result.candidates === 0) {
+      console.log("All your notes already have a transcript — nothing to backfill.");
+      return;
+    }
+    console.log(`Attributed ${result.updated} of ${result.candidates} notes (${result.ambiguous} ambiguous, ${result.noBatch} without a local mining batch). Run 'dosu knowledge report' to see their traces.`);
+  });
   cmd.addCommand(hooksCommand());
   return cmd;
 }
@@ -84272,4 +84428,4 @@ execute().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=d438e963-a417-e96d-6475-6e2164756e21
+//# debugId=971484cf-da0f-e0c4-6475-6e2164756e21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dosu/cli",
-  "version": "0.53.0-beta.7",
+  "version": "0.53.0-beta.9",
   "type": "module",
   "description": "Dosu CLI - Manage MCP servers for AI tools",
   "license": "MIT",