@dosu/cli 0.55.1 → 0.56.1

package/bin/dosu.js

@@ -1050,7 +1050,7 @@ function isNpxInvocation(channel = INSTALL_CHANNEL, env = process.env) {
 function getVersionString() {
   return `v${VERSION}`;
 }
-var VERSION = "0.55.1", INSTALL_CHANNEL = "npm";
+var VERSION = "0.56.1", INSTALL_CHANNEL = "npm";
 
 // src/debug/logger.ts
 import {
@@ -1902,6 +1902,7 @@ function loadSyncState(configDir = getConfigDir()) {
     const studiedSessions = Array.isArray(raw.mined_sessions) ? raw.mined_sessions.filter((record) => typeof record === "object" && record !== null && typeof record.at === "string" && typeof record.session === "string").map((record) => ({
       at: record.at,
       session: record.session,
+      ...typeof record.updated === "string" ? { updated: record.updated } : {},
       ...typeof record.project === "string" ? { project: record.project } : {}
     })) : [];
     const rawRefusal = raw.last_refusal;
@@ -13429,6 +13430,27 @@ function batchWatermark(batch) {
   }
   return newest;
 }
+function sessionKey(session) {
+  return `${session.harness}/${session.id}`;
+}
+function studiedRecords(sessions, at) {
+  return sessions.map((s) => ({
+    at,
+    session: sessionKey(s),
+    updated: s.updated,
+    ...s.project ? { project: s.project } : {}
+  }));
+}
+function lastStudiedSnapshot(history) {
+  const latest = new Map;
+  for (const record of history ?? []) {
+    const updated = record.updated ? Date.parse(record.updated) : Number.NaN;
+    if (!Number.isNaN(updated) && updated > (latest.get(record.session) ?? Number.NEGATIVE_INFINITY)) {
+      latest.set(record.session, updated);
+    }
+  }
+  return latest;
+}
 async function runKnowledgeSync(options = {}) {
   const deps = options.deps ?? {};
   const loadState = deps.loadState ?? loadSyncState;
@@ -13511,14 +13533,20 @@ async function runKnowledgeSync(options = {}) {
     }
     const worthStudying = deps.worthStudying ?? isWorthStudying;
     const isIncognito = deps.isIncognito ?? isIncognitoSession;
+    const studiedSnapshot = lastStudiedSnapshot(state.mined_sessions);
     const examined = [];
     const batch = [];
     let trivial = 0;
     let incognito = 0;
+    let alreadyStudied = 0;
     for (let i = ready.length - 1;i >= 0 && batch.length < MINE_BATCH_LIMIT; i--) {
       const candidate = ready[i];
       examined.push(candidate);
-      if (isIncognito(candidate)) {
+      const key = sessionKey(candidate);
+      if (Date.parse(candidate.updated) <= (studiedSnapshot.get(key) ?? Number.NEGATIVE_INFINITY)) {
+        alreadyStudied += 1;
+        logger.debug("sync", `skipping already-studied session ${key}`);
+      } else if (isIncognito(candidate)) {
         incognito += 1;
         logger.debug("sync", `skipping incognito session ${candidate.harness}/${candidate.id}`);
       } else if (worthStudying(candidate)) {
@@ -13527,7 +13555,7 @@ async function runKnowledgeSync(options = {}) {
         trivial += 1;
       }
     }
-    const skippedNote = `${trivial} trivial, ${incognito} incognito skipped`;
+    const skippedNote = `${trivial} trivial, ${incognito} incognito${alreadyStudied > 0 ? `, ${alreadyStudied} already studied` : ""} skipped`;
     if (batch.length === 0) {
       saveState({
         ...state,
@@ -13546,29 +13574,41 @@ async function runKnowledgeSync(options = {}) {
     }
     logger.debug("sync", `studying ${batch.length} of ${ready.length} ready sessions (${skippedNote})`);
     const learner = await deps.mine(batch);
+    const sessionTokens = deps.sessionTokens ?? estimateSessionTokens;
+    const noted = new Set(learner.notedSessions ?? []);
+    const notedBatch = batch.filter((s) => noted.has(sessionKey(s)));
+    const partialProgress = (at) => {
+      if (notedBatch.length === 0)
+        return {};
+      let tokens = 0;
+      for (const s of notedBatch)
+        tokens += sessionTokens(s);
+      logger.debug("sync", `recorded ${notedBatch.length} noted sessions from the ${learner.outcome} run`);
+      return {
+        mined_sessions: [...state.mined_sessions ?? [], ...studiedRecords(notedBatch, at)].slice(-STUDIED_HISTORY_LIMIT),
+        total_mined: (state.total_mined ?? 0) + notedBatch.length,
+        total_notes: (state.total_notes ?? 0) + learner.notesWritten,
+        total_learning_tokens: (state.total_learning_tokens ?? 0) + tokens
+      };
+    };
     switch (learner.outcome) {
       case "completed": {
         for (const s of batch) {
           logger.debug("sync", `studied session ${s.harness}/${s.id}`);
         }
-        const studiedAt = now().toISOString();
+        const completedAt = now().toISOString();
         const history = [
           ...state.mined_sessions ?? [],
-          ...batch.map((s) => ({
-            at: studiedAt,
-            session: `${s.harness}/${s.id}`,
-            ...s.project ? { project: s.project } : {}
-          }))
+          ...studiedRecords(batch, completedAt)
         ].slice(-STUDIED_HISTORY_LIMIT);
         const watermark = batchWatermark(examined);
-        const sessionTokens = deps.sessionTokens ?? estimateSessionTokens;
         let batchTokens = 0;
         for (const s of batch)
           batchTokens += sessionTokens(s);
         saveState({
           ...state,
           watermark,
-          last_attempt_at: studiedAt,
+          last_attempt_at: completedAt,
           consecutive_failures: 0,
           mined_sessions: history,
           total_mined: (state.total_mined ?? 0) + batch.length,
@@ -13588,10 +13628,12 @@ async function runKnowledgeSync(options = {}) {
       }
       case "consent_off":
       case "credit_limit":
-      case "quota_exceeded": {
+      case "quota_exceeded":
+      case "claude_code_missing": {
         const at = now().toISOString();
         saveState({
           ...state,
+          ...partialProgress(at),
           last_attempt_at: at,
           consecutive_failures: 0,
           last_refusal: {
@@ -13600,13 +13642,14 @@ async function runKnowledgeSync(options = {}) {
             message: learner.message ?? "Studying unavailable right now."
           }
         });
-        logger.debug("sync", `studying skipped by gateway: ${learner.outcome}`);
+        logger.debug("sync", `studying skipped: ${learner.outcome}`);
         return { status: "skipped-gateway", ...base, studiedSessions: 0, learner };
       }
       default: {
         const at = now().toISOString();
         saveState({
           ...state,
+          ...partialProgress(at),
           last_attempt_at: at,
           consecutive_failures: state.consecutive_failures + 1,
           ...learner.outcome === "gateway_rejected" && learner.message ? { last_refusal: { at, outcome: learner.outcome, message: learner.message } } : {}
@@ -13637,7 +13680,7 @@ var init_sync = __esm(() => {
 });
 
 // src/telemetry/debug-id.ts
-var BUNDLE_DEBUG_ID_PLACEHOLDER = "737a8f86-5677-f74d-6475-6e2164756e21";
+var BUNDLE_DEBUG_ID_PLACEHOLDER = "93db7db7-907f-4d14-6475-6e2164756e21";
 
 // src/telemetry/telemetry.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -13862,12 +13905,19 @@ function consumeCommandFacets() {
 function allowlisted(value, allowed) {
   return typeof value === "string" && allowed.has(value) ? value : undefined;
 }
+function matching(value, pattern) {
+  return typeof value === "string" && pattern.test(value) ? value : undefined;
+}
 function sanitizeFacets(facets) {
   if (!facets || typeof facets !== "object")
     return {};
   const trigger = allowlisted(facets.sync_trigger, SYNC_TRIGGERS);
   const status = allowlisted(facets.sync_status, SYNC_STATUSES);
   const learner = allowlisted(facets.learner_outcome, LEARNER_OUTCOMES);
+  const gatewayReason = allowlisted(facets.gateway_reason, GATEWAY_REASONS);
+  const claudeSource = allowlisted(facets.claude_code_source, CLAUDE_CODE_SOURCES);
+  const claudeVersion = matching(facets.claude_code_version, CLAUDE_CODE_VERSION_PATTERN);
+  const model = matching(facets.learner_model, LEARNER_MODEL_PATTERN);
   const backfill = allowlisted(facets.backfill_offer, BACKFILL_OFFERS);
   return {
     ...trigger ? { sync_trigger: trigger } : {},
@@ -13875,6 +13925,10 @@ function sanitizeFacets(facets) {
     ...facets.sessions_studied !== undefined ? { sessions_studied: countBucket(facets.sessions_studied) } : {},
     ...facets.notes_written !== undefined ? { notes_written: countBucket(facets.notes_written) } : {},
     ...learner ? { learner_outcome: learner } : {},
+    ...gatewayReason ? { gateway_reason: gatewayReason } : {},
+    ...claudeSource ? { claude_code_source: claudeSource } : {},
+    ...claudeVersion ? { claude_code_version: claudeVersion } : {},
+    ...model ? { learner_model: model } : {},
     ...backfill ? { backfill_offer: backfill } : {}
   };
 }
@@ -13964,7 +14018,13 @@ function parseSentryDsn(value) {
     return null;
   }
 }
-function sentryTags(command, context, runtime, error) {
+function sentryTags(command, context, runtime, error, facets) {
+  const facetTags = {};
+  for (const key of SENTRY_FACET_TAGS) {
+    const value = facets[key];
+    if (value)
+      facetTags[key] = value;
+  }
   return {
     schema_version: "1",
     command,
@@ -13980,9 +14040,21 @@ function sentryTags(command, context, runtime, error) {
     is_authenticated: String(context.isAuthenticated),
     ...error.code ? { error_code: error.code } : {},
     ...error.status ? { http_status: String(error.status) } : {},
-    ...error.exitCode === undefined ? {} : { exit_code: String(error.exitCode) }
+    ...error.exitCode === undefined ? {} : { exit_code: String(error.exitCode) },
+    ...facetTags
   };
 }
+function failedLearnerOutcome(facets) {
+  return facets.learner_outcome === "completed" ? undefined : facets.learner_outcome;
+}
+function exceptionSummary(command, error, facets) {
+  if (facets.learner_outcome === "completed")
+    return error.code ?? error.type;
+  const outcome = facets.learner_outcome ?? facets.sync_status;
+  if (!outcome)
+    return error.code ?? error.type;
+  return `${command}: ${outcome}${facets.gateway_reason ? ` (${facets.gateway_reason})` : ""}`;
+}
 function buildSentryEnvelope(input) {
   const parsedDsn = parseSentryDsn(input.dsn);
   if (!parsedDsn || !validEventId(input.eventId))
@@ -13990,6 +14062,7 @@ function buildSentryEnvelope(input) {
   const context = normalizeContext(input.context);
   const runtime = normalizeRuntime(input.runtime);
   const command = canonicalCommand(input.command);
+  const facets = sanitizeFacets(input.facets);
   const debugId = validDebugId(input.debugId) ? input.debugId.toLowerCase() : undefined;
   const error = {
     type: validErrorType(input.error.type) ? input.error.type : "Error",
@@ -14009,7 +14082,7 @@ function buildSentryEnvelope(input) {
   };
   const exceptionValue = {
     type: error.type,
-    value: error.code ?? error.type,
+    value: exceptionSummary(command, error, facets),
     ...error.frames.length > 0 ? { stacktrace: { frames: error.frames } } : {}
   };
   const newestFrame = error.frames.at(-1);
@@ -14022,7 +14095,7 @@ function buildSentryEnvelope(input) {
     platform: "node",
     level: "error",
     release: `dosu-cli@${runtime.version}`,
-    tags: sentryTags(command, context, runtime, error),
+    tags: sentryTags(command, context, runtime, error, facets),
     ...context.user ? {
       user: {
         id: context.user.id,
@@ -14034,7 +14107,15 @@ function buildSentryEnvelope(input) {
         images: [{ type: "sourcemap", code_file: BUNDLE_CODE_FILE, debug_id: debugId }]
       }
     } : {},
-    fingerprint: ["dosu-cli", command, error.type, error.code ?? "unknown", safeCallsite],
+    fingerprint: [
+      "dosu-cli",
+      command,
+      error.type,
+      error.code ?? "unknown",
+      safeCallsite,
+      ...failedLearnerOutcome(facets) ? [facets.learner_outcome] : [],
+      ...facets.gateway_reason ? [facets.gateway_reason] : []
+    ],
     exception: { values: [exceptionValue] }
   };
   const envelopeHeader = {
@@ -14275,15 +14356,17 @@ function createCommandTelemetry(settings, dependencies = {}) {
   async function dispatch(result, exitCode, error) {
     try {
       const tasks = [];
+      let facets;
+      if (!disabled) {
+        try {
+          facets = resolveFacets();
+        } catch {
+          facets = undefined;
+        }
+      }
       if (!disabled && analyticsToken) {
         const id = context.user?.id ?? installId();
         if (id) {
-          let facets;
-          try {
-            facets = resolveFacets();
-          } catch {
-            facets = undefined;
-          }
           const payload = buildPostHogPayload({
             apiKey: analyticsToken,
             ...context.user ? {} : { installId: id },
@@ -14311,14 +14394,16 @@ function createCommandTelemetry(settings, dependencies = {}) {
           }
         }
       }
-      if (!disabled && result === "failure" && error && shouldSendToSentry(error) && sentryDsn) {
+      const sentryError = result === "failure" && error && shouldSendToSentry(error) ? error : result === "success" && sanitizeFacets(facets).sync_status === "mine-failed" ? { type: "LearnerRunFailed", frames: [] } : undefined;
+      if (!disabled && sentryError && sentryDsn) {
         const id = eventId(generateUuid);
         const envelope = id ? buildSentryEnvelope({
           dsn: sentryDsn,
           command,
           context,
           runtime,
-          error,
+          error: sentryError,
+          ...facets ? { facets } : {},
           eventId: id,
           timestampMs: safeNow(now),
           debugId: BUNDLE_DEBUG_ID_PLACEHOLDER
@@ -14370,7 +14455,7 @@ function createCommandTelemetry(settings, dependencies = {}) {
 function shouldSendToSentry(error) {
   return !["SESSION_EXPIRED", "SESSION_PERSISTENCE_ERROR"].includes(error.code ?? "");
 }
-var REQUEST_TIMEOUT_MS = 500, MAX_RESPONSE_BYTES, MAX_STACK_FRAMES = 20, UNKNOWN_COMMAND = "unknown", FALLBACK_INSTALL_ID = "00000000-0000-4000-8000-000000000000", BUNDLE_CODE_FILE = "app:///bin/dosu.js", CLI_PACKAGE_ROOT, SAFE_ERROR_TYPES, SAFE_ERROR_CODES, SYNC_TRIGGERS, SYNC_STATUSES, LEARNER_OUTCOMES, BACKFILL_OFFERS, pendingFacets;
+var REQUEST_TIMEOUT_MS = 500, MAX_RESPONSE_BYTES, MAX_STACK_FRAMES = 20, UNKNOWN_COMMAND = "unknown", FALLBACK_INSTALL_ID = "00000000-0000-4000-8000-000000000000", BUNDLE_CODE_FILE = "app:///bin/dosu.js", CLI_PACKAGE_ROOT, SAFE_ERROR_TYPES, SAFE_ERROR_CODES, SYNC_TRIGGERS, SYNC_STATUSES, LEARNER_OUTCOMES, GATEWAY_REASONS, CLAUDE_CODE_SOURCES, CLAUDE_CODE_VERSION_PATTERN, LEARNER_MODEL_PATTERN, BACKFILL_OFFERS, SENTRY_FACET_TAGS, pendingFacets;
 var init_telemetry = __esm(() => {
   MAX_RESPONSE_BYTES = 1024 * 1024;
   CLI_PACKAGE_ROOT = detectCliPackageRoot();
@@ -14381,6 +14466,7 @@ var init_telemetry = __esm(() => {
     "CliUsageError",
     "CommandExitError",
     "Error",
+    "LearnerRunFailed",
     "OAuthCallbackError",
     "RangeError",
     "ReferenceError",
@@ -14474,8 +14560,21 @@ var init_telemetry = __esm(() => {
     "credit_limit",
     "quota_exceeded",
     "gateway_rejected",
+    "claude_code_missing",
     "error"
   ]);
+  GATEWAY_REASONS = new Set([
+    "system_role_unsupported",
+    "adaptive_thinking_unsupported",
+    "effort_unsupported",
+    "unsupported_request",
+    "max_tokens",
+    "context_length",
+    "other"
+  ]);
+  CLAUDE_CODE_SOURCES = new Set(["sdk", "system", "missing"]);
+  CLAUDE_CODE_VERSION_PATTERN = /^\d{1,4}\.\d{1,4}\.\d{1,6}(?:-[0-9A-Za-z]{1,16}(?:\.[0-9A-Za-z]{1,16}){0,3})?$/;
+  LEARNER_MODEL_PATTERN = /^claude-[a-z0-9.-]{1,56}$/;
   BACKFILL_OFFERS = new Set([
     "not-offered",
     "accepted",
@@ -14483,6 +14582,15 @@ var init_telemetry = __esm(() => {
     "cancelled",
     "spawn-failed"
   ]);
+  SENTRY_FACET_TAGS = [
+    "sync_trigger",
+    "sync_status",
+    "learner_outcome",
+    "gateway_reason",
+    "claude_code_source",
+    "claude_code_version",
+    "learner_model"
+  ];
 });
 
 // src/commands/agent-select.ts
@@ -15073,12 +15181,14 @@ function buildLearnerEnv(options) {
   const headers = [
     `x-dosu-run-id: ${options.runID}`,
     `x-dosu-trigger: ${options.trigger}`,
-    `x-dosu-cli-version: ${options.cliVersion}`
+    `x-dosu-cli-version: ${options.cliVersion}`,
+    `x-dosu-expected-model: ${options.model}`
   ];
   if (options.deploymentID)
     headers.push(`x-dosu-deployment-id: ${options.deploymentID}`);
   env.ANTHROPIC_BASE_URL = options.gatewayURL;
   env.ANTHROPIC_AUTH_TOKEN = options.apiKey;
+  env.ANTHROPIC_MODEL = options.model;
   env.ANTHROPIC_CUSTOM_HEADERS = headers.join(`
 `);
   env.CLAUDE_CONFIG_DIR = options.configDir;
@@ -15136,11 +15246,44 @@ function findSystemClaude(env = process.env, homeDir = homedir6()) {
 function resolveClaudeExecutable(options = {}) {
   const hasSdkBinary = options.sdkBinaryExists ?? sdkNativeBinaryExists;
   if (hasSdkBinary())
-    return;
-  return findSystemClaude(options.env, options.homeDir);
+    return { kind: "sdk" };
+  const path = findSystemClaude(options.env, options.homeDir);
+  return path ? { kind: "system", path } : { kind: "missing" };
 }
 var init_executable = () => {};
 
+// src/learner/model.ts
+async function resolveServedModel(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  try {
+    const base = options.gatewayURL.replace(/\/+$/, "");
+    const resp = await fetchImpl(`${base}/capabilities`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${options.apiKey}` },
+      signal: AbortSignal.timeout(options.timeoutMs ?? CAPABILITIES_TIMEOUT_MS)
+    });
+    if (!resp.ok) {
+      logger.debug("learner", `gateway capabilities returned ${resp.status}; using default model`);
+      return DEFAULT_LEARNER_MODEL;
+    }
+    const body = await resp.json();
+    const model = body?.model;
+    if (typeof model === "string" && CLAUDE_MODEL_PATTERN.test(model))
+      return model;
+    logger.debug("learner", "gateway capabilities named no usable model; using default model");
+    return DEFAULT_LEARNER_MODEL;
+  } catch (error) {
+    const text = error instanceof Error ? error.message : String(error);
+    logger.debug("learner", `gateway capabilities failed (${text}); using default model`);
+    return DEFAULT_LEARNER_MODEL;
+  }
+}
+var DEFAULT_LEARNER_MODEL = "claude-haiku-4-5", CAPABILITIES_TIMEOUT_MS = 5000, CLAUDE_MODEL_PATTERN;
+var init_model = __esm(() => {
+  init_logger();
+  CLAUDE_MODEL_PATTERN = /^claude-[a-z0-9.-]+$/;
+});
+
 // src/learner/prompt.ts
 function buildLearnerSystemPrompt(coreRules) {
   return `You are Dosu's knowledge learner. You read a developer's recent coding-agent sessions and save the durable, non-obvious findings to the team's shared knowledge base so future teammates and agents do not have to rediscover them.
@@ -58104,6 +58247,13 @@ function snippet(value) {
   const flat = (text ?? "").replace(/\s+/g, " ").trim();
   return flat.length > TRACE_SNIPPET_LIMIT ? `${flat.slice(0, TRACE_SNIPPET_LIMIT)}…` : flat;
 }
+function classifyRejectionReason(detail) {
+  for (const [pattern, reason] of REJECTION_REASONS) {
+    if (pattern.test(detail))
+      return reason;
+  }
+  return "other";
+}
 function classifyGatewayRejection(text) {
   const match = API_400_PATTERN.exec(text);
   if (!match)
@@ -58116,7 +58266,8 @@ function classifyGatewayRejection(text) {
   } catch {}
   return {
     outcome: "gateway_rejected",
-    message: `LLM gateway rejected the study run: ${snippet(detail)}`
+    message: `LLM gateway rejected the study run: ${snippet(detail)}`,
+    reason: classifyRejectionReason(detail.trim())
   };
 }
 function traceAgentMessage(message) {
@@ -58164,11 +58315,26 @@ async function runLearner(options) {
       message: "LLM gateway URL is not set. From source, use `bun run dev` (production endpoints) or `bun run dev:local` (local stack)."
     };
   }
-  await Promise.resolve().then(() => init_sdk());
   const claudeExecutable = resolveClaudeExecutable();
-  if (claudeExecutable) {
-    logger.debug("learner", `using system Claude Code executable: ${claudeExecutable}`);
+  if (claudeExecutable.kind === "missing") {
+    return {
+      outcome: "claude_code_missing",
+      notesWritten: 0,
+      turns: 0,
+      claudeCodeSource: "missing",
+      message: "Studying runs on Claude Code, which isn't installed here. Install Claude Code, then run `dosu knowledge sync`."
+    };
   }
+  if (claudeExecutable.kind === "system") {
+    logger.debug("learner", `using system Claude Code executable: ${claudeExecutable.path}`);
+  }
+  const model = await resolveServedModel({ gatewayURL, apiKey: options.apiKey });
+  logger.debug("learner", `study run model: ${model}`);
+  const diagnostics = {
+    claudeCodeSource: claudeExecutable.kind,
+    model
+  };
+  await Promise.resolve().then(() => init_sdk());
   const configDir = createRunConfigDir();
   const runID = options.runID ?? crypto.randomUUID();
   const sessionStartedAt = options.sessions.map((s) => s.updated).sort()[0];
@@ -58179,7 +58345,19 @@ async function runLearner(options) {
   let notesWritten = 0;
   let currentSession;
   const readsSinceWrite = new Set;
+  const sessionKeys = new Map(options.sessions.map((s) => [s.id, `${s.harness}/${s.id}`]));
+  const notedSessions = new Set;
+  const pendingNotes = new Map;
   let turns = 0;
+  const finish = (outcome, message, gatewayReason) => ({
+    outcome,
+    notesWritten,
+    notedSessions: [...notedSessions],
+    turns,
+    ...message === undefined ? {} : { message },
+    ...gatewayReason ? { gatewayReason } : {},
+    ...diagnostics
+  });
   const env = buildLearnerEnv({
     apiKey: options.apiKey,
     gatewayURL,
@@ -58187,19 +58365,21 @@ async function runLearner(options) {
     runID,
     trigger: options.trigger,
     cliVersion: getVersionString(),
-    deploymentID: options.deploymentID
+    deploymentID: options.deploymentID,
+    model
   });
   try {
     const run = PGt({
       prompt: buildLearnerPrompt(options.sessions),
       options: {
         systemPrompt: buildLearnerSystemPrompt(LEARNER_CORE_RULES),
+        model,
         env,
         abortController: abort,
         maxTurns: options.maxTurns ?? DEFAULT_MAX_TURNS,
         settingSources: [],
         persistSession: false,
-        ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
+        ...claudeExecutable.kind === "system" ? { pathToClaudeCodeExecutable: claudeExecutable.path } : {},
         sandbox: { enabled: true, failIfUnavailable: false },
         mcpServers: {
           [SESSIONS_SERVER_NAME]: createSessionToolsServer(options.sessions),
@@ -58215,7 +58395,7 @@ async function runLearner(options) {
           }
         },
         stderr: (data) => logger.debug("learner", `[sdk] ${data}`),
-        canUseTool: async (toolName, input) => {
+        canUseTool: async (toolName, input, { toolUseID }) => {
           if (!allowed.has(toolName)) {
             return {
               behavior: "deny",
@@ -58246,6 +58426,9 @@ async function runLearner(options) {
             }
             notesWritten += 1;
             readsSinceWrite.clear();
+            const noted = currentSession && sessionKeys.get(currentSession);
+            if (noted)
+              pendingNotes.set(toolUseID, noted);
             const { transcript_id: _authoredByModel, ...clean } = input;
             return {
               behavior: "allow",
@@ -58258,56 +58441,46 @@ async function runLearner(options) {
     });
     for await (const message of run) {
       traceAgentMessage(message);
+      if (message.type === "user" && Array.isArray(message.message.content)) {
+        for (const block of message.message.content) {
+          const noted = block.type === "tool_result" && pendingNotes.get(block.tool_use_id);
+          if (noted && block.is_error !== true)
+            notedSessions.add(noted);
+        }
+      }
+      if (message.type === "system" && message.subtype === "init" && typeof message.claude_code_version === "string") {
+        diagnostics.claudeCodeVersion = message.claude_code_version;
+      }
       if (message.type === "result") {
         turns = message.num_turns;
         const text = message.subtype === "success" ? message.result : message.subtype;
         const gatewayError = classifyGatewayError(text ?? "") ?? (message.is_error ? classifyGatewayRejection(text ?? "") : null);
         if (gatewayError) {
-          return {
-            outcome: gatewayError.outcome,
-            notesWritten,
-            turns,
-            message: gatewayError.message
-          };
+          return finish(gatewayError.outcome, gatewayError.message, gatewayError.reason);
         }
         if (message.subtype !== "success" || message.is_error) {
           logger.debug("learner", `run ${runID} failed: ${text}`);
-          return {
-            outcome: "error",
-            notesWritten,
-            turns,
-            message: "Study run failed; see debug log for details."
-          };
+          return finish("error", "Study run failed; see debug log for details.");
         }
         logger.debug("learner", `run ${runID} completed: ${turns} turns, ${notesWritten} suggested pages`);
-        return { outcome: "completed", notesWritten, turns, message: text };
+        return finish("completed", text);
       }
     }
-    return {
-      outcome: "error",
-      notesWritten,
-      turns,
-      message: "Study run ended without a result."
-    };
+    return finish("error", "Study run ended without a result.");
   } catch (error) {
     const text = error instanceof Error ? error.message : String(error);
     const gatewayError = classifyGatewayError(text) ?? classifyGatewayRejection(text);
     if (gatewayError) {
-      return { outcome: gatewayError.outcome, notesWritten, turns, message: gatewayError.message };
+      return finish(gatewayError.outcome, gatewayError.message, gatewayError.reason);
     }
     logger.debug("learner", `run ${runID} threw: ${text}`);
-    return {
-      outcome: "error",
-      notesWritten,
-      turns,
-      message: abort.signal.aborted ? "Study run timed out and was aborted." : "Study run failed; see debug log for details."
-    };
+    return finish("error", abort.signal.aborted ? "Study run timed out and was aborted." : "Study run failed; see debug log for details.");
   } finally {
     clearTimeout(timer);
     configDir.cleanup();
   }
 }
-var DEFAULT_MAX_TURNS = 160, DEFAULT_MAX_NOTES = 80, DEFAULT_TIMEOUT_MS2, KNOWLEDGE_SERVER_NAME = "dosu", GATEWAY_ERRORS, TRACE_SNIPPET_LIMIT = 400, API_400_PATTERN;
+var DEFAULT_MAX_TURNS = 160, DEFAULT_MAX_NOTES = 80, DEFAULT_TIMEOUT_MS2, KNOWLEDGE_SERVER_NAME = "dosu", GATEWAY_ERRORS, TRACE_SNIPPET_LIMIT = 400, REJECTION_REASONS, API_400_PATTERN;
 var init_runner = __esm(() => {
   init_logger();
   init_config_helpers();
@@ -58316,6 +58489,7 @@ var init_runner = __esm(() => {
   init_conflicts();
   init_env();
   init_executable();
+  init_model();
   init_tools();
   DEFAULT_TIMEOUT_MS2 = 30 * 60 * 1000;
   GATEWAY_ERRORS = {
@@ -58332,6 +58506,14 @@ var init_runner = __esm(() => {
       message: "Daily Dosu Remote Sessions budget reached; runs resume tomorrow."
     }
   };
+  REJECTION_REASONS = [
+    [/^dosu_unsupported_request:/, "unsupported_request"],
+    [/\beffort\b|output_config/i, "effort_unsupported"],
+    [/\brole\b.*\bsystem\b|\bsystem\b.*\brole\b|messages\.\d+\.role/i, "system_role_unsupported"],
+    [/\badaptive\b/i, "adaptive_thinking_unsupported"],
+    [/prompt is too long|context (?:limit|length|window)/i, "context_length"],
+    [/max_tokens/i, "max_tokens"]
+  ];
   API_400_PATTERN = /API Error: 400\b\s*(.*)/s;
 });
 
@@ -58495,7 +58677,7 @@ ${results.length - opts.limit} more results not shown.`));
       sync_status: outcome.status,
       sessions_studied: sessionsStudied,
       notes_written: notesWritten,
-      ...outcome.learner ? { learner_outcome: outcome.learner.outcome } : {}
+      ...outcome.learner ? learnerFacets(outcome.learner) : {}
     });
     if (opts.quiet)
       return;
@@ -58555,6 +58737,15 @@ ${results.length - opts.limit} more results not shown.`));
   cmd.addCommand(statuslineCommand2());
   return cmd;
 }
+function learnerFacets(learner) {
+  return {
+    learner_outcome: learner.outcome,
+    ...learner.gatewayReason ? { gateway_reason: learner.gatewayReason } : {},
+    ...learner.claudeCodeSource ? { claude_code_source: learner.claudeCodeSource } : {},
+    ...learner.claudeCodeVersion ? { claude_code_version: learner.claudeCodeVersion } : {},
+    ...learner.model ? { learner_model: learner.model } : {}
+  };
+}
 function buildLearner(trigger) {
   const cfg = loadConfig();
   if (cfg.mode === "oss")
@@ -62592,10 +62783,18 @@ function allowlistedWorkflowProperties(properties) {
   if (Array.isArray(input.providers)) {
     safe.providers = input.providers.filter((provider) => typeof provider === "string" && /^[a-z][a-z0-9-]{0,31}$/.test(provider)).slice(0, 50);
   }
-  for (const key of ["completed_mcp", "completed_skill", "completed_agents_md"]) {
+  for (const key of [
+    "completed_mcp",
+    "completed_skill",
+    "completed_agents_md",
+    "completed_hooks"
+  ]) {
     if (typeof input[key] === "boolean")
       safe[key] = input[key];
   }
+  if (typeof input.hook_count === "number" && Number.isInteger(input.hook_count) && input.hook_count >= 0 && input.hook_count <= 50) {
+    safe.hook_count = input.hook_count;
+  }
   return safe;
 }
 function safeIdentifier(value, maxLength) {
@@ -63272,10 +63471,13 @@ async function runSetupFlow(opts = {}) {
     agentsMdCompleted = await stepUpdateAgentsMd();
   }
   if (mcpCompleted || skillCompleted || agentsMdCompleted) {
+    const hookCount = configuredProviders.filter((result) => result.hook).length;
     trackInBackground(trackCliOnboardingEvent(cfg, onboardingRunID, "cli_onboarding_completed", {
       completed_mcp: mcpCompleted,
       completed_skill: skillCompleted,
-      completed_agents_md: agentsMdCompleted
+      completed_agents_md: agentsMdCompleted,
+      completed_hooks: hookCount > 0,
+      hook_count: hookCount
     }));
   }
   if (mcpCompleted && cfg.mode !== MODE_OSS) {
@@ -66405,4 +66607,4 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=737a8f86-5677-f74d-6475-6e2164756e21
+//# debugId=93db7db7-907f-4d14-6475-6e2164756e21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dosu/cli",
-  "version": "0.55.1",
+  "version": "0.56.1",
   "type": "module",
   "description": "Dosu CLI - Manage MCP servers for AI tools",
   "license": "MIT",