@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/config/model-tools.js

@@ -376,6 +376,26 @@ const DEFAULT_MODEL_CONFIGS = [
         patchFormat: 'search_replace',
         strengths: ['french'],
     },
+    // Lemonade GGUF ids (`Qwen3.6-35B-A3B-MTP-GGUF`) must win over the hosted
+    // `qwen3.6*` row below. That hosted row is a 262k OpenRouter ceiling with the
+    // default (standard) prompt profile — in the agent loop it drowns the model
+    // in schemas and the model shells `list_peers` via `bash` instead of calling
+    // `peer_tool_invoke` (mission 8: 33.7 tok/s raw tools OK, 9× bash in-loop).
+    // Match is case-insensitive (`matchModel` /i). Keep the same lite surface as
+    // `gemma4*` which completed the fleet recipe.
+    {
+        model: 'Qwen3.6-*-GGUF*',
+        strengths: ['code', 'french'],
+        supportsReasoning: true,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 32768,
+        maxOutputTokens: 8192,
+        maxToolRounds: 20,
+        disabledTools: ['apply_patch', 'browser', 'computer_control'],
+        patchFormat: 'search_replace',
+        promptProfile: 'lite',
+    },
     // Qwen 3.5 → 3.7 hébergés (262 144 chez tous les fournisseurs OpenRouter). Un runtime local
     // qui en sert moins abaisse la valeur via la découverte Ollama/LM Studio.
     {
@@ -896,6 +916,56 @@ const DEFAULT_MODEL_CONFIGS = [
         patchFormat: 'full_file',
         promptProfile: 'lite',
     },
+    {
+        model: 'qwen2.5:14b*',
+        strengths: ['french'],
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 32768,
+        maxOutputTokens: 4096,
+        patchFormat: 'search_replace',
+    },
+    {
+        model: 'qwen2.5:32b*',
+        strengths: ['french'],
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 32768,
+        maxOutputTokens: 8192,
+        patchFormat: 'search_replace',
+    },
+    {
+        model: 'qwen2.5:72b*',
+        strengths: ['french'],
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 32768,
+        maxOutputTokens: 8192,
+        patchFormat: 'search_replace',
+    },
+    {
+        model: 'qwen2.5-coder:14b*',
+        strengths: ['french', 'code'],
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 32768,
+        maxOutputTokens: 4096,
+        patchFormat: 'search_replace',
+    },
+    {
+        model: 'qwen2.5-coder:32b*',
+        strengths: ['french', 'code'],
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 32768,
+        maxOutputTokens: 8192,
+        patchFormat: 'search_replace',
+    },
     {
         model: 'qwen2.5*',
         strengths: ['french'],
@@ -904,6 +974,7 @@ const DEFAULT_MODEL_CONFIGS = [
         // tool_calls) via Ollama, so the agent can't execute them — it stays
         // chat-only. Verified flaky against scripts/autonomy-lab/ (unlike qwen3,
         // which does emit structured calls). Use qwen3+ for autonomous editing.
+        // Explicitly split by size: 14b+ are promoted above, <14b stay gated.
         supportsToolCalls: false,
         supportsVision: false,
         contextWindow: 32768,
@@ -962,9 +1033,37 @@ const DEFAULT_MODEL_CONFIGS = [
         patchFormat: 'full_file',
         promptProfile: 'lite',
     },
+    {
+        model: 'llama3.1:70b*',
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 131072,
+        maxOutputTokens: 8192,
+        patchFormat: 'search_replace',
+    },
+    {
+        model: 'llama3.1:405b*',
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 131072,
+        maxOutputTokens: 8192,
+        patchFormat: 'search_replace',
+    },
+    {
+        model: 'llama3.3*',
+        supportsReasoning: false,
+        supportsToolCalls: true,
+        supportsVision: false,
+        contextWindow: 131072,
+        maxOutputTokens: 8192,
+        patchFormat: 'search_replace',
+    },
     {
         model: 'llama3*',
         supportsReasoning: false,
+        // Explicitly split by size: 70b+ promoted above, 8b and below stay gated.
         supportsToolCalls: false,
         supportsVision: false,
         contextWindow: 8192,
@@ -1169,6 +1268,10 @@ export function resetRuntimeModelContextCache() {
 export function findModelToolConfig(modelName, customConfigs) {
     return findConfigMatch(modelName, [...(customConfigs || []), ...DEFAULT_MODEL_CONFIGS])?.config ?? null;
 }
+/** Read-only view of the built-in table (consistency tests, e.g. P5 `codeExecEvidence`). */
+export function listDefaultModelToolConfigs() {
+    return DEFAULT_MODEL_CONFIGS.map((config) => Object.freeze({ ...config }));
+}
 export function getModelToolConfig(modelName, customConfigs) {
     // Use cache for default config lookups (hot path)
     if (!customConfigs && _configCache.has(modelName)) {

package/dist/context/context-manager-v2.js

@@ -12,6 +12,7 @@
  * - Content-type-aware Compression
  * - Key Information Preservation
  */
+import { truncateOutput } from '../utils/bounded-output.js';
 import { createHash } from 'node:crypto';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -703,8 +704,7 @@ export class ContextManagerV2 {
                 if (msg.content.length > MAX_TOOL_RESULT_LENGTH) {
                     return {
                         ...msg,
-                        content: msg.content.substring(0, MAX_TOOL_RESULT_LENGTH) +
-                            '\n... [truncated for context limits]',
+                        content: truncateOutput(msg.content, MAX_TOOL_RESULT_LENGTH),
                     };
                 }
             }

package/dist/context/lm-resizer-compressor.js

@@ -44,8 +44,9 @@ function stringArray(value) {
 /** Resolve lm-resizer: explicit env -> stable install -> PATH -> mutable DEV build. */
 export function resolveLmResizerBin() {
     const env = process.env.CODEBUDDY_LM_RESIZER_BIN;
-    if (env && existsSync(env))
-        return env;
+    // An explicit choice must not silently fall through to an older binary.
+    if (env?.trim())
+        return env.trim();
     const stable = join(homedir(), '.local', 'bin', 'lm-resizer');
     if (existsSync(stable))
         return stable;

package/dist/context/lm-resizer-diagnostics.d.ts

@@ -0,0 +1,9 @@
+/** Read-only host probe. Availability alone does not establish protocol support. */
+export declare function diagnoseLmResizer(): Promise<{
+    binary: string;
+    enabled: boolean;
+    available: boolean;
+    toolOutputSupported: boolean;
+    version: string;
+    warning: string;
+}>;

package/dist/context/lm-resizer-diagnostics.js

@@ -0,0 +1,30 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { isLmResizerEnabled, resolveLmResizerBin } from './lm-resizer-compressor.js';
+const run = promisify(execFile);
+/** Read-only host probe. Availability alone does not establish protocol support. */
+export async function diagnoseLmResizer() {
+    const binary = resolveLmResizerBin();
+    const result = { binary, enabled: isLmResizerEnabled(), available: false, toolOutputSupported: false, version: 'unknown', warning: '' };
+    const options = { timeout: 3000, maxBuffer: 64 * 1024, windowsHide: true };
+    try {
+        await run(binary, ['--help'], options);
+        result.available = true;
+        try {
+            result.version = (await run(binary, ['--version'], options)).stdout.trim();
+        }
+        catch { /* Older CLI has no version flag. */ }
+        try {
+            const probe = await run(binary, ['tool-output', '--help'], options);
+            result.toolOutputSupported = /tool-output/.test(probe.stdout);
+        }
+        catch { /* Old protocol: retain raw observations. */ }
+        if (!result.toolOutputSupported)
+            result.warning = 'This binary lacks the tool-output protocol. Buddy keeps raw observations; install a compatible release to enable observation compression.';
+    }
+    catch {
+        result.warning = 'LM Resizer is unavailable on the host. Buddy keeps raw observations.';
+    }
+    return result;
+}
+//# sourceMappingURL=lm-resizer-diagnostics.js.map

package/dist/context/tool-output-masking.js

@@ -9,6 +9,7 @@
  * Inspired by Gemini CLI's toolOutputMaskingService.ts
  */
 import { logger } from '../utils/logger.js';
+import { truncateOutput } from '../utils/bounded-output.js';
 /** Tokens worth of newest tool outputs to protect from masking */
 const PROTECTION_THRESHOLD_CHARS = 200_000; // ~50K tokens * 4 chars/token
 /** Only trigger masking if total prunable chars exceeds this */
@@ -41,14 +42,12 @@ function generatePreview(content) {
         // Short enough — use char-based preview
         if (content.length <= SHORT_PREVIEW_CHARS * 2)
             return content;
-        return content.substring(0, SHORT_PREVIEW_CHARS) +
-            '\n...\n' +
-            content.substring(content.length - SHORT_PREVIEW_CHARS);
+        return truncateOutput(content, SHORT_PREVIEW_CHARS * 2);
     }
     const head = lines.slice(0, HEAD_PREVIEW_LINES).join('\n');
     const tail = lines.slice(-TAIL_PREVIEW_LINES).join('\n');
     const omitted = lines.length - HEAD_PREVIEW_LINES - TAIL_PREVIEW_LINES;
-    return `${head}\n\n... (${omitted} lines omitted) ...\n\n${tail}`;
+    return truncateOutput(`${head}\n\n... (${omitted} lines omitted) ...\n\n${tail}`, 4000);
 }
 /**
  * Apply tool output masking to conversation messages.

package/dist/curator/curator.d.ts

@@ -63,6 +63,12 @@ export interface CuratorDeps {
     }>>;
     /** Ledger de performance modèles (défaut : ~/.codebuddy/fleet-model-performance.jsonl). */
     modelLedgerPath?: string;
+    /** Activité des skills (défaut : readSkillActivity(), journal ~/.codebuddy/skill-usage). */
+    skillActivity?: () => Map<string, {
+        lastActivityAt: string;
+    }>;
+    /** Skills référencées par une tâche planifiée (défaut : jobs.json du scheduler cron). */
+    scheduledSkills?: () => Promise<Set<string>>;
 }
 export declare function runCuratorScan(cwd?: string, deps?: CuratorDeps): Promise<CuratorReport>;
 /**

package/dist/curator/curator.js

@@ -81,6 +81,23 @@ async function scanAuthoredSkills(deps, cwd, now) {
     const patches = [];
     let authored = 0;
     let pinned = 0;
+    let scheduled = 0;
+    let activity = new Map();
+    try {
+        activity = deps.skillActivity
+            ? deps.skillActivity()
+            : (await import('../skills/skill-usage-store.js')).readSkillActivity();
+    }
+    catch {
+        // Télémétrie absente : repli sur la date de modification.
+    }
+    let scheduledSkills = new Set();
+    try {
+        scheduledSkills = deps.scheduledSkills ? await deps.scheduledSkills() : await readScheduledSkillNames();
+    }
+    catch {
+        // Pas de scheduler lisible : aucune protection supplémentaire.
+    }
     let entries = [];
     try {
         entries = await fs.readdir(skillsDir);
@@ -103,12 +120,22 @@ async function scanAuthoredSkills(deps, cwd, now) {
                 pinned++;
                 continue; // une skill épinglée n'est jamais proposée
             }
-            const ageDays = (now.getTime() - stat.mtime.getTime()) / DAY_MS;
+            if (scheduledSkills.has(entry)) {
+                scheduled++;
+                continue; // utilisée par une tâche planifiée : jamais dormante
+            }
+            // Ancre = dernière activité (vue/usage) ou dernière modification, la plus récente.
+            const lastActivity = Date.parse(activity.get(entry)?.lastActivityAt ?? '');
+            const anchor = Math.max(stat.mtime.getTime(), Number.isFinite(lastActivity) ? lastActivity : 0);
+            const ageDays = (now.getTime() - anchor) / DAY_MS;
             if (ageDays >= STALE_SKILL_DAYS) {
+                const usedBefore = Number.isFinite(lastActivity);
                 patches.push({
                     kind: 'REVIEW_SKILL',
                     target: entry,
-                    reason: `non modifiée depuis ${Math.round(ageDays)}j et non épinglée`,
+                    reason: usedBefore
+                        ? `aucune activité ni modification depuis ${Math.round(ageDays)}j, non épinglée`
+                        : `jamais utilisée et non modifiée depuis ${Math.round(ageDays)}j, non épinglée`,
                     autoAppliable: false, // juger l'utilité d'une skill = décision humaine
                     howToApply: `buddy improve skills-pin ${entry} (garder) ou buddy improve skills-consolidate (fusionner/archiver)`,
                 });
@@ -122,11 +149,34 @@ async function scanAuthoredSkills(deps, cwd, now) {
         section: {
             name: 'Skills authored',
             ok: true,
-            summary: `${authored} authored (${pinned} épinglée(s)), ${patches.length} dormante(s) ≥ ${STALE_SKILL_DAYS}j à réviser`,
+            summary: `${authored} authored (${pinned} épinglée(s), ${scheduled} planifiée(s)), ${patches.length} dormante(s) ≥ ${STALE_SKILL_DAYS}j sans activité à réviser`,
         },
         patches,
     };
 }
+/** Noms de skills référencées par une tâche cron `skill` (lecture seule de jobs.json). */
+async function readScheduledSkillNames() {
+    const root = process.env.CODEBUDDY_CRON_HOME
+        ? path.resolve(process.env.CODEBUDDY_CRON_HOME)
+        : path.join(os.homedir(), '.codebuddy', 'cron');
+    const names = new Set();
+    let raw = '';
+    try {
+        raw = await fs.readFile(path.join(root, 'jobs.json'), 'utf-8');
+    }
+    catch {
+        return names;
+    }
+    const jobs = JSON.parse(raw);
+    if (!Array.isArray(jobs))
+        return names;
+    for (const job of jobs) {
+        const task = job?.task;
+        if (task?.type === 'skill' && typeof task.skill === 'string' && task.skill.trim())
+            names.add(task.skill.trim());
+    }
+    return names;
+}
 async function scanCkg(deps) {
     const getStats = deps.ckgStats ??
         (async () => {

package/dist/daemon/cron-agent-bridge.d.ts

@@ -25,6 +25,11 @@ export interface BridgeConfig {
      * Left undefined, the bridge behaves exactly as before (no run records).
      */
     runStore?: RunStore;
+    /**
+     * Directory of per-job notepad files. Defaults to `$CODEBUDDY_CRON_HOME/notepads`
+     * (or `~/.codebuddy/cron/notepads`). Isolated from jobs.json.
+     */
+    notepadDir?: string;
 }
 export interface JobExecutionResult {
     jobId: string;
@@ -50,6 +55,7 @@ export interface JobExecutionResult {
 export declare class CronAgentBridge extends EventEmitter {
     private config;
     private activeJobs;
+    private notepad;
     constructor(config: BridgeConfig);
     /**
      * Create a task executor function for the CronScheduler

package/dist/daemon/cron-agent-bridge.js

@@ -10,6 +10,7 @@ import { executeHermesLifecycleHook } from '../hooks/hermes-lifecycle-hooks.js';
 import { evaluateCronPreCheck } from '../scheduler/pre-check-runner.js';
 import { runWatchdog } from '../scheduler/watchdog-handlers.js';
 import { collectDeliveryTargets, resolveDeliveryBody } from '../scheduler/scheduled-delivery.js';
+import { JobNotepadStore, defaultNotepadDir, isContinuityEnabled, } from '../scheduler/job-notepad.js';
 const DEFAULT_BRIDGE_CONFIG = {
     maxToolRounds: 20,
     jobTimeoutMs: 300000, // 5 minutes
@@ -20,9 +21,11 @@ const DEFAULT_BRIDGE_CONFIG = {
 export class CronAgentBridge extends EventEmitter {
     config;
     activeJobs = new Map();
+    notepad;
     constructor(config) {
         super();
         this.config = { ...DEFAULT_BRIDGE_CONFIG, ...config };
+        this.notepad = new JobNotepadStore(config.notepadDir ?? defaultNotepadDir());
     }
     /**
      * Create a task executor function for the CronScheduler
@@ -44,11 +47,13 @@ export class CronAgentBridge extends EventEmitter {
         try {
             // Pre-check gate: skip expensive LLM work when nothing changed.
             // Watchdog jobs are non-LLM monitors, so they bypass the pre-check.
+            // Fingerprint is applied only after a skip or a successful task — a
+            // failed run must leave lastFingerprint alone so an unchanged source retries.
+            let pendingFingerprint;
             if (job.preCheck && job.task.type !== 'watchdog') {
                 const preCheckResult = await evaluateCronPreCheck(job.preCheck);
                 if (typeof preCheckResult.fingerprint === 'string') {
-                    // Persisted by the scheduler's persistJobs() after this returns.
-                    job.preCheck.lastFingerprint = preCheckResult.fingerprint;
+                    pendingFingerprint = preCheckResult.fingerprint;
                 }
                 this.emit('job:precheck', {
                     jobId: job.id,
@@ -57,6 +62,9 @@ export class CronAgentBridge extends EventEmitter {
                     evidence: preCheckResult.evidence,
                 });
                 if (!preCheckResult.shouldRun) {
+                    if (pendingFingerprint !== undefined) {
+                        job.preCheck.lastFingerprint = pendingFingerprint;
+                    }
                     const duration = Date.now() - startTime;
                     const skipOutput = `Skipped by pre-check: ${preCheckResult.reason}`;
                     this.recordRunEvent(recordedRunId, 'decision', {
@@ -139,6 +147,17 @@ export class CronAgentBridge extends EventEmitter {
             // data channel, capped at 64KB in the script runner). For all other
             // task types, the full output serves as outputData.
             const outputData = job.task.type === 'script' ? scriptStdout : output;
+            if (pendingFingerprint !== undefined && job.preCheck) {
+                job.preCheck.lastFingerprint = pendingFingerprint;
+            }
+            if (isContinuityEnabled(job.continuity)) {
+                try {
+                    await this.notepad.saveLastSuccessfulOutput(job.id, outputData ?? output);
+                }
+                catch (err) {
+                    logger.warn('Cron task succeeded but its continuity output could not be saved', { jobId: job.id, error: String(err) });
+                }
+            }
             const result = {
                 jobId: job.id,
                 runId: recordedRunId ?? `run-${Date.now()}`,
@@ -253,10 +272,18 @@ export class CronAgentBridge extends EventEmitter {
                 logger.debug(`Cron job ${job.id}: could not load session ${job.resolvedSessionId}, starting fresh`);
             }
         }
-        // Prepend inputData from parent chained job if available
         let message = job.task.message;
+        const prefixes = [];
+        if (isContinuityEnabled(job.continuity)) {
+            const section = await this.notepad.renderSection(job.id);
+            if (section)
+                prefixes.push(section.trimEnd());
+        }
         if (inputData) {
-            message = `[Chained job context — output from parent job]:\n${inputData}\n\n[Task]:\n${message}`;
+            prefixes.push(`[Chained job context — output from parent job]:\n${inputData}`);
+        }
+        if (prefixes.length > 0) {
+            message = `${prefixes.join('\n\n')}\n\n[Task]:\n${message}`;
         }
         const entries = await agent.processUserMessage(message);
         const assistantEntries = entries.filter(e => e.type === 'assistant');

package/dist/doctor/index.d.ts

@@ -32,7 +32,10 @@ export interface DoctorSummary {
  * so `doctor` on a fresh machine reports 0 warnings for missing optional tools.
  */
 export declare function summarizeDoctorChecks(checks: DoctorCheck[]): DoctorSummary;
-export declare function checkTtsProviders(): DoctorCheck[];
+/** PATH lookup without a child process (used by `buddy triage`). */
+export declare function commandExistsOnPath(cmd: string, env?: NodeJS.ProcessEnv): boolean;
+type CommandLookup = (cmd: string) => boolean;
+export declare function checkTtsProviders(lookup?: CommandLookup): DoctorCheck[];
 /**
  * Check the server configuration derived from environment/defaults. Explicit
  * CLI flags are diagnosed again from the effective config when the server
@@ -47,5 +50,11 @@ export type { OllamaModelCandidate } from '../wizard/environment-detection.js';
 export declare function resolveOllamaModel(models: readonly string[], settings?: OllamaSelectionSettings): string | undefined;
 /** Both persisted model fields must point at a model currently served by Ollama. */
 export declare function isOllamaSelectionCurrent(models: readonly string[], settings?: OllamaSelectionSettings): boolean;
-export declare function runDoctorChecks(cwd?: string): Promise<DoctorCheck[]>;
+export interface DoctorRunOptions {
+    /** Skip every network call: live key validation, OAuth refresh/discovery, local runtime probes. */
+    offline?: boolean;
+    /** Never start a child process: PATH/.git filesystem lookups, sandbox probe skipped (`buddy triage`). */
+    noSubprocess?: boolean;
+}
+export declare function runDoctorChecks(cwd?: string, options?: DoctorRunOptions): Promise<DoctorCheck[]>;
 export declare function runFixes(checks: DoctorCheck[]): Promise<FixResult[]>;

package/dist/doctor/index.js

@@ -43,8 +43,34 @@ function commandExists(cmd) {
         return false;
     }
 }
-function getCommandAvailability(cmd) {
-    return commandExists(cmd) ? 'installed' : 'not found';
+/** PATH lookup without a child process (used by `buddy triage`). */
+export function commandExistsOnPath(cmd, env = process.env) {
+    const executable = (file) => {
+        try {
+            if (!statSync(file).isFile())
+                return false;
+            accessSync(file, fsConstants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (cmd.includes('/') || cmd.includes('\\'))
+        return executable(cmd);
+    const extensions = process.platform === 'win32'
+        ? ['', ...(env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)]
+        : [''];
+    for (const dir of (env.PATH ?? env.Path ?? '').split(process.platform === 'win32' ? ';' : ':')) {
+        if (!dir)
+            continue;
+        if (extensions.some((ext) => executable(join(dir, cmd + ext))))
+            return true;
+    }
+    return false;
+}
+function getCommandAvailability(cmd, lookup = commandExists) {
+    return lookup(cmd) ? 'installed' : 'not found';
 }
 function checkNodeVersion() {
     const major = parseInt(process.version.slice(1), 10);
@@ -79,7 +105,7 @@ async function checkNativeSqlite() {
         };
     }
 }
-function checkDependencies() {
+function checkDependencies(lookup = commandExists) {
     const checks = [];
     // Optionality is INTRINSIC to the tool, never derived from whether it is
     // installed: deriving `optional: !installed` would silently reclassify ANY
@@ -131,7 +157,7 @@ function checkDependencies() {
         },
     ];
     for (const dep of externalTools) {
-        const installed = getCommandAvailability(dep.cmd) === 'installed';
+        const installed = getCommandAvailability(dep.cmd, lookup) === 'installed';
         checks.push({
             name: dep.label,
             status: installed ? 'ok' : dep.level,
@@ -140,7 +166,7 @@ function checkDependencies() {
         });
     }
     const audioPlayers = ['ffplay', 'aplay', 'mpv'];
-    const found = audioPlayers.filter(cmd => commandExists(cmd));
+    const found = audioPlayers.filter(cmd => lookup(cmd));
     checks.push({
         name: 'Audio playback',
         status: found.length > 0 ? 'ok' : 'warn',
@@ -171,7 +197,7 @@ function checkApiKeys() {
  * credentials present (user might be using API keys instead — non-fatal).
  * `error` only when the file is corrupt or refresh fails.
  */
-async function checkChatGptOAuth() {
+async function checkChatGptOAuth(offline = false) {
     try {
         const { hasCodexCredentials, getChatGptAuth, getCodexAuthFilePath } = await import('../providers/codex-oauth.js');
         if (!hasCodexCredentials()) {
@@ -181,6 +207,14 @@ async function checkChatGptOAuth() {
                 message: `not signed in (run \`buddy login\` to use your ChatGPT subscription) — file: ${getCodexAuthFilePath()}`,
             };
         }
+        if (offline) {
+            // getChatGptAuth() may refresh (network + token rotation): never offline.
+            return {
+                name: 'ChatGPT OAuth',
+                status: 'ok',
+                message: 'credential file present (token refresh and model discovery skipped: --offline)',
+            };
+        }
         const auth = await getChatGptAuth();
         if (!auth) {
             return {
@@ -283,8 +317,8 @@ function checkStaleLockFiles(cwd) {
     }
     return checks;
 }
-export function checkTtsProviders() {
-    const pocketLauncher = ['pocket-tts', 'uvx'].find((command) => commandExists(command));
+export function checkTtsProviders(lookup = commandExists) {
+    const pocketLauncher = ['pocket-tts', 'uvx'].find((command) => lookup(command));
     const available = [];
     if (pocketLauncher)
         available.push(`Pocket TTS (via ${pocketLauncher})`);
@@ -377,7 +411,10 @@ function checkProfilePermissions() {
         message: `${dir} writable (mode ${mode.toString(8)})`,
     };
 }
-function checkNativeSandbox() {
+function checkNativeSandbox(noSubprocess = false) {
+    if (noSubprocess) {
+        return { name: 'Native sandbox (kernel)', status: 'ok', message: 'not probed (no child process in this mode); run `buddy doctor` to probe bwrap/Landlock', optional: true };
+    }
     const caps = detectNativeSandboxCapabilities();
     return {
         name: 'Native sandbox (kernel)',
@@ -386,10 +423,26 @@ function checkNativeSandbox() {
         optional: true,
     };
 }
-function checkGit(cwd) {
-    if (!commandExists('git')) {
+function insideGitWorkTree(cwd) {
+    let dir = cwd;
+    for (;;) {
+        if (existsSync(join(dir, '.git')))
+            return true;
+        const parent = join(dir, '..');
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+}
+function checkGit(cwd, noSubprocess = false) {
+    if (!(noSubprocess ? commandExistsOnPath('git') : commandExists('git'))) {
         return { name: 'Git', status: 'error', message: 'git not found' };
     }
+    if (noSubprocess) {
+        return insideGitWorkTree(cwd)
+            ? { name: 'Git', status: 'ok', message: 'installed, inside a git repo (.git found)' }
+            : { name: 'Git', status: 'warn', message: 'installed, but not inside a git repo (no .git found)' };
+    }
     try {
         execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore' });
         return { name: 'Git', status: 'ok', message: 'installed, inside a git repo' };
@@ -605,9 +658,9 @@ export function isOllamaSelectionCurrent(models, settings = {}) {
  * it" (env var / onboarded settings / OAuth / API key), because a running
  * Ollama that was never selected still dead-ends the first chat.
  */
-async function checkProviderReadiness() {
+async function checkProviderReadiness(offline = false) {
     const { detectEnvironment } = await import('../wizard/environment-detection.js');
-    const snap = await detectEnvironment();
+    const snap = await detectEnvironment({ offline });
     const oauthOrKey = snap.capabilities.some((c) => c.available && (c.kind === 'oauth' || c.kind === 'api-key'));
     const ollama = snap.capabilities.find((c) => c.id === 'ollama');
     const ollamaModels = ollama?.models?.length ?? 0;
@@ -651,6 +704,13 @@ async function checkProviderReadiness() {
         };
     }
     const configured = oauthOrKey || ((envLocal || onboardedLocal) && ollamaModels > 0);
+    if (offline && !configured && (envLocal || onboardedLocal)) {
+        return {
+            name: 'AI provider ready',
+            status: 'warn',
+            message: `local ${p || 'runtime'} configured but not probed (--offline); run \`buddy doctor\` without --offline to verify it`,
+        };
+    }
     if (configured) {
         const rec = snap.recommended;
         return {
@@ -737,30 +797,33 @@ function checkProviderFailoverHealth() {
         message: lines.slice(1).join('; ') || `${down.length} provider(s) benched`,
     };
 }
-export async function runDoctorChecks(cwd) {
+export async function runDoctorChecks(cwd, options = {}) {
     const dir = cwd ?? process.cwd();
+    const offline = options.offline === true;
+    const noSubprocess = options.noSubprocess === true;
+    const lookup = noSubprocess ? (cmd) => commandExistsOnPath(cmd) : commandExists;
     const { checkLlmKeysLive } = await import('./llm-key-check.js');
     return [
-        await checkProviderReadiness(),
+        await checkProviderReadiness(offline),
         checkNodeVersion(),
         await checkNativeSqlite(),
-        ...checkDependencies(),
+        ...checkDependencies(lookup),
         ...checkApiKeys(),
         // Validation LIVE des clés configurées (endpoint /models, 0 token) :
         // distingue clé invalide (401/403 → error) de quota épuisé (429 → warn).
-        ...(await checkLlmKeysLive()),
-        await checkChatGptOAuth(),
+        ...(offline ? [] : await checkLlmKeysLive()),
+        await checkChatGptOAuth(offline),
         ...checkConfigFiles(dir),
         // Accidents de collage dans .env (commande shell, guillemets, doublons) —
         // détectés sans jamais afficher les valeurs. src/doctor/env-sanity.ts.
         ...(await import('./env-sanity.js')).checkEnvSanity(dir),
         ...checkStaleLockFiles(dir),
-        ...checkTtsProviders(),
+        ...checkTtsProviders(lookup),
         checkServerExposureEnvironment(),
         checkProfilePermissions(),
         checkDiskSpace(dir),
-        checkGit(dir),
-        checkNativeSandbox(),
+        checkGit(dir, noSubprocess),
+        checkNativeSandbox(noSubprocess),
         checkProviderFailoverHealth(),
     ];
 }