@promptwheel/cli 0.7.2 → 0.7.4

package/dist/lib/solo-auto-between-cycles.js

@@ -56,7 +56,7 @@ export async function runPreCycleMaintenance(state) {
         if (qualityRate < 0.5) {
             state.effectiveMinConfidence += 10;
             if (state.options.verbose) {
-                console.log(chalk.gray(`  Quality rate ${(qualityRate * 100).toFixed(0)}% — raising confidence +10`));
+                state.displayAdapter.log(chalk.gray(`  Quality rate ${(qualityRate * 100).toFixed(0)}% — raising confidence +10`));
             }
         }
     }
@@ -66,7 +66,8 @@ export async function runPreCycleMaintenance(state) {
             const confDelta = calibrateConfidence(state.repoRoot, state.effectiveMinConfidence, state.autoConf.minConfidence ?? 20);
             if (confDelta !== 0) {
                 state.effectiveMinConfidence += confDelta;
-                console.log(chalk.gray(`  Confidence calibration: ${confDelta > 0 ? '+' : ''}${confDelta} → ${state.effectiveMinConfidence}`));
+                if (state.options.verbose)
+                    state.displayAdapter.log(chalk.gray(`  Confidence calibration: ${confDelta > 0 ? '+' : ''}${confDelta} → ${state.effectiveMinConfidence}`));
             }
         }
         catch {
@@ -77,7 +78,7 @@ export async function runPreCycleMaintenance(state) {
     if (state.runMode === 'spin' && state.pendingPrUrls.length > 0 && state.deliveryMode !== 'direct') {
         const openRatio = state.pendingPrUrls.length / state.maxPrs;
         if (openRatio > 0.7) {
-            console.log(chalk.yellow(`  Backpressure: ${state.pendingPrUrls.length}/${state.maxPrs} PRs open — waiting for reviews...`));
+            state.displayAdapter.log(chalk.yellow(`  Backpressure: ${state.pendingPrUrls.length}/${state.maxPrs} PRs open — waiting for reviews...`));
             await sleep(15000);
             state.cycleCount--; // undo increment so the cycle reruns
             return { shouldSkipCycle: true };
@@ -85,7 +86,7 @@ export async function runPreCycleMaintenance(state) {
         else if (openRatio > 0.4) {
             state.effectiveMinConfidence += 15;
             if (state.options.verbose) {
-                console.log(chalk.gray(`  Light backpressure (${state.pendingPrUrls.length}/${state.maxPrs} open) — raising confidence +15`));
+                state.displayAdapter.log(chalk.gray(`  Light backpressure (${state.pendingPrUrls.length}/${state.maxPrs} open) — raising confidence +15`));
             }
         }
     }
@@ -94,7 +95,7 @@ export async function runPreCycleMaintenance(state) {
     const CONFIDENCE_CEILING = 80;
     if (state.effectiveMinConfidence > CONFIDENCE_CEILING) {
         if (state.options.verbose) {
-            console.log(chalk.gray(`  Confidence clamped: ${state.effectiveMinConfidence} → ${CONFIDENCE_CEILING} (ceiling)`));
+            state.displayAdapter.log(chalk.gray(`  Confidence clamped: ${state.effectiveMinConfidence} → ${CONFIDENCE_CEILING} (ceiling)`));
         }
         state.effectiveMinConfidence = CONFIDENCE_CEILING;
     }
@@ -107,7 +108,7 @@ export async function runPreCycleMaintenance(state) {
         state.tasteProfile = buildTasteProfile(state.sectorState, state.allLearnings, rs.formulaStats);
         saveTasteProfile(state.repoRoot, state.tasteProfile);
         if (state.options.verbose) {
-            console.log(chalk.gray(`  Taste profile rebuilt: prefer [${state.tasteProfile.preferredCategories.join(', ')}], avoid [${state.tasteProfile.avoidCategories.join(', ')}]`));
+            state.displayAdapter.log(chalk.gray(`  Taste profile rebuilt: prefer [${state.tasteProfile.preferredCategories.join(', ')}], avoid [${state.tasteProfile.avoidCategories.join(', ')}]`));
         }
     }
     // Periodic pull
@@ -122,21 +123,21 @@ export async function runPreCycleMaintenance(state) {
                     if (mergeResult.status === 0) {
                         const summary = mergeResult.stdout?.trim();
                         if (summary && !summary.includes('Already up to date')) {
-                            console.log(chalk.cyan(`  ⬇ Pulled latest from origin/${state.detectedBaseBranch}`));
+                            state.displayAdapter.log(chalk.cyan(`  ⬇ Pulled latest from origin/${state.detectedBaseBranch}`));
                         }
                     }
                     else {
                         const errMsg = mergeResult.stderr?.trim() || 'fast-forward not possible';
                         if (state.pullPolicy === 'halt') {
-                            console.log();
-                            console.log(chalk.red(`✗ HCF — Base branch has diverged from origin/${state.detectedBaseBranch}`));
-                            console.log(chalk.gray(`  ${errMsg}`));
-                            console.log();
-                            console.log(chalk.bold('Resolution:'));
-                            console.log(`  1. Resolve the divergence (rebase, merge, or reset)`);
-                            console.log(`  2. Re-run: promptwheel`);
-                            console.log();
-                            console.log(chalk.gray(`  To keep going despite divergence, set pullPolicy: "warn" in config.`));
+                            state.displayAdapter.log('');
+                            state.displayAdapter.log(chalk.red(`✗ HCF — Base branch has diverged from origin/${state.detectedBaseBranch}`));
+                            state.displayAdapter.log(chalk.gray(`  ${errMsg}`));
+                            state.displayAdapter.log('');
+                            state.displayAdapter.log(chalk.bold('Resolution:'));
+                            state.displayAdapter.log(`  1. Resolve the divergence (rebase, merge, or reset)`);
+                            state.displayAdapter.log(`  2. Re-run: promptwheel`);
+                            state.displayAdapter.log('');
+                            state.displayAdapter.log(chalk.gray(`  To keep going despite divergence, set pullPolicy: "warn" in config.`));
                             // Signal orchestrator to break — finalizeSession handles cleanup
                             state.shutdownRequested = true;
                             if (state.shutdownReason === null)
@@ -144,14 +145,14 @@ export async function runPreCycleMaintenance(state) {
                             return { shouldSkipCycle: true };
                         }
                         else {
-                            console.log(chalk.yellow(`  ⚠ Base branch diverged from origin/${state.detectedBaseBranch} — continuing on stale base`));
-                            console.log(chalk.gray(`    ${errMsg}`));
-                            console.log(chalk.gray(`    Subsequent work may produce merge conflicts`));
+                            state.displayAdapter.log(chalk.yellow(`  ⚠ Base branch diverged from origin/${state.detectedBaseBranch} — continuing on stale base`));
+                            state.displayAdapter.log(chalk.gray(`    ${errMsg}`));
+                            state.displayAdapter.log(chalk.gray(`    Subsequent work may produce merge conflicts`));
                         }
                     }
                 }
-                else if (state.options.verbose) {
-                    console.log(chalk.yellow(`  ⚠ Fetch failed (network?): ${fetchResult.stderr?.trim()}`));
+                else if (state.options.verbose) { // already verbose-gated
+                    state.displayAdapter.log(chalk.yellow(`  ⚠ Fetch failed (network?): ${fetchResult.stderr?.trim()}`));
                 }
             }
             catch {
@@ -240,7 +241,7 @@ export async function runPreCycleMaintenance(state) {
         try {
             state.guidelines = loadGuidelines(state.repoRoot, state.guidelinesOpts);
             if (state.guidelines && state.options.verbose) {
-                console.log(chalk.gray(`  Refreshed project guidelines (${state.guidelines.source})`));
+                state.displayAdapter.log(chalk.gray(`  Refreshed project guidelines (${state.guidelines.source})`));
             }
         }
         catch {
@@ -306,7 +307,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                             }
                         }
                         if (healed.length > 0) {
-                            console.log(chalk.green(`  Baseline healed: ${healed.join(', ')} now passing`));
+                            state.displayAdapter.log(chalk.green(`  Baseline healed: ${healed.join(', ')} now passing`));
                             if (state.autoConf.learningsEnabled) {
                                 addLearning(state.repoRoot, {
                                     text: `Baseline healed in ${scope}: ${healed.join(', ')} now pass after cycle ${state.cycleCount}`.slice(0, 200),
@@ -337,7 +338,8 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
             }
         }
         catch (err) {
-            console.warn(chalk.gray(`  Baseline healing skipped: ${err instanceof Error ? err.message : String(err)}`));
+            if (state.options.verbose)
+                console.warn(chalk.gray(`  Baseline healing skipped: ${err instanceof Error ? err.message : String(err)}`));
         }
     }
     // Meta-learning extraction (aggregate pattern detection)
@@ -352,7 +354,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                 existingLearnings: state.allLearnings,
             });
             if (metaInsightsAdded > 0 && state.options.verbose) {
-                console.log(chalk.gray(`  Meta-learnings: ${metaInsightsAdded} process insight(s) extracted`));
+                state.displayAdapter.log(chalk.gray(`  Meta-learnings: ${metaInsightsAdded} process insight(s) extracted`));
             }
         }
         catch {
@@ -365,13 +367,13 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
         state.consecutiveLowYieldCycles++;
         const MAX_LOW_YIELD_CYCLES = state.drillMode ? 5 : 3;
         if (state.consecutiveLowYieldCycles >= MAX_LOW_YIELD_CYCLES) {
-            console.log(chalk.yellow(`  ${state.consecutiveLowYieldCycles} consecutive low-yield cycles — diminishing returns, stopping`));
+            state.displayAdapter.log(chalk.yellow(`  ${state.consecutiveLowYieldCycles} consecutive low-yield cycles — diminishing returns, stopping`));
             state.shutdownRequested = true;
             if (state.shutdownReason === null)
                 state.shutdownReason = 'low_yield';
         }
         else if (state.options.verbose) {
-            console.log(chalk.gray(`  Low-yield cycle (${state.consecutiveLowYieldCycles}/${MAX_LOW_YIELD_CYCLES})`));
+            state.displayAdapter.log(chalk.gray(`  Low-yield cycle (${state.consecutiveLowYieldCycles}/${MAX_LOW_YIELD_CYCLES})`));
         }
     }
     else if (completedThisCount > 0) {
@@ -389,7 +391,8 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
         const confValue = state.effectiveMinConfidence;
         const insightsStr = metaInsightsAdded > 0 ? ` | insights +${metaInsightsAdded}` : '';
         const baselineStr = baselineFailing > 0 ? ` | baseline failing ${baselineFailing}` : '';
-        console.log(chalk.gray(`  Spin: quality ${qualityPct}% | confidence ${confValue}${baselineStr}${insightsStr}`));
+        if (state.options.verbose)
+            state.displayAdapter.log(chalk.gray(`  Spin: quality ${qualityPct}% | confidence ${confValue}${baselineStr}${insightsStr}`));
     }
     // Convergence metrics
     if (state.cycleCount >= 3 && state.sectorState) {
@@ -413,7 +416,8 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
             };
         }
         const metrics = computeConvergenceMetrics(state.sectorState, state.allLearnings.length, rs.recentCycles ?? [], sessionCtx, drillCtx);
-        console.log(chalk.gray(`  ${formatConvergenceOneLiner(metrics)}`));
+        if (state.options.verbose)
+            state.displayAdapter.log(chalk.gray(`  ${formatConvergenceOneLiner(metrics)}`));
         if (metrics.suggestedAction === 'stop') {
             if (state.activeTrajectory && state.activeTrajectoryState) {
                 // Adaptive threshold: use historical completion rate to decide when to abandon
@@ -431,13 +435,13 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                 const completedSteps = state.activeTrajectory.steps.filter(s => state.activeTrajectoryState.stepStates[s.id]?.status === 'completed').length;
                 const progressPct = totalSteps > 0 ? Math.round((completedSteps / totalSteps) * 100) : 0;
                 if (progressPct < abandonThreshold) {
-                    console.log(chalk.yellow(`  Convergence suggests stopping — trajectory "${state.activeTrajectory.name}" only ${progressPct}% complete, skipping it`));
+                    state.displayAdapter.log(chalk.yellow(`  Convergence suggests stopping — trajectory "${state.activeTrajectory.name}" only ${progressPct}% complete, skipping it`));
                     if (state.drillMode) {
                         try {
                             finishDrillTrajectory(state, 'stalled');
                         }
                         catch (err) {
-                            console.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
+                            state.displayAdapter.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
                         }
                     }
                     state.activeTrajectory = null;
@@ -448,11 +452,11 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                         state.shutdownReason = 'convergence';
                 }
                 else {
-                    console.log(chalk.gray(`  Convergence suggests stopping, but trajectory "${state.activeTrajectory.name}" is ${progressPct}% complete — continuing`));
+                    state.displayAdapter.log(chalk.gray(`  Convergence suggests stopping, but trajectory "${state.activeTrajectory.name}" is ${progressPct}% complete — continuing`));
                 }
             }
             else {
-                console.log(chalk.yellow(`  Convergence suggests stopping — most sectors polished, low yield.`));
+                state.displayAdapter.log(chalk.yellow(`  Convergence suggests stopping — most sectors polished, low yield.`));
                 state.shutdownRequested = true;
                 if (state.shutdownReason === null)
                     state.shutdownReason = 'convergence';
@@ -466,19 +470,19 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
             // In drill mode with active trajectory, don't widen — stay focused on trajectory scope
             if (state.drillMode && state.currentTrajectoryStep?.scope) {
                 if (state.options.verbose)
-                    console.log(chalk.gray(`  Scope adjustment: drill mode — staying focused on trajectory scope`));
+                    state.displayAdapter.log(chalk.gray(`  Scope adjustment: drill mode — staying focused on trajectory scope`));
             }
             else {
                 state.effectiveMinConfidence = state.autoConf.minConfidence ?? 20;
                 if (state.options.verbose)
-                    console.log(chalk.gray(`  Scope adjustment: widening (resetting confidence threshold)`));
+                    state.displayAdapter.log(chalk.gray(`  Scope adjustment: widening (resetting confidence threshold)`));
             }
         }
         else if (scopeAdj === 'narrow' && state.drillMode && state.currentTrajectoryStep) {
             // In drill mode, tighten confidence when trajectory-guided to focus on high-quality proposals
             state.effectiveMinConfidence += 5;
             if (state.options.verbose)
-                console.log(chalk.gray(`  Scope adjustment: drill-narrowed (confidence +5)`));
+                state.displayAdapter.log(chalk.gray(`  Scope adjustment: drill-narrowed (confidence +5)`));
         }
     }
     // Cross-sector pattern learning
@@ -531,12 +535,12 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
         try {
             state.codebaseIndex = refreshCodebaseIndex(state.codebaseIndex, state.repoRoot, state.excludeDirs);
             if (state.options.verbose) {
-                console.log(chalk.gray(`  Codebase index refreshed: ${state.codebaseIndex.modules.length} modules`));
+                state.displayAdapter.log(chalk.gray(`  Codebase index refreshed: ${state.codebaseIndex.modules.length} modules`));
             }
             if (state.sectorState) {
                 state.sectorState = refreshSectors(state.repoRoot, state.sectorState, state.codebaseIndex.modules);
                 if (state.options.verbose) {
-                    console.log(chalk.gray(`  Sectors refreshed: ${state.sectorState.sectors.length} sector(s)`));
+                    state.displayAdapter.log(chalk.gray(`  Sectors refreshed: ${state.sectorState.sectors.length} sector(s)`));
                 }
             }
         }
@@ -558,7 +562,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
             const arrow = state.activeGoal.measure.direction === 'up'
                 ? (delta > 0 ? chalk.green('↑') : delta < 0 ? chalk.yellow('↓') : '→')
                 : (delta < 0 ? chalk.green('↓') : delta > 0 ? chalk.yellow('↑') : '→');
-            console.log(chalk.cyan(`  🎯 ${state.activeGoal.name}: ${value} ${arrow} (${deltaSign}${delta.toFixed(1)}) target: ${state.activeGoal.measure.target}`));
+            state.displayAdapter.log(chalk.cyan(`  🎯 ${state.activeGoal.name}: ${value} ${arrow} (${deltaSign}${delta.toFixed(1)}) target: ${state.activeGoal.measure.target}`));
             // Check if goal is now met
             const { target, direction } = state.activeGoal.measure;
             const met = direction === 'up' ? value >= target : value <= target;
@@ -566,7 +570,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
             const measurement = { ...state.activeGoalMeasurement, current: value, measuredAt: Date.now(), met };
             recordGoalMeasurement(state.repoRoot, measurement);
             if (met) {
-                console.log(chalk.green(`  ✓ Goal "${state.activeGoal.name}" met!`));
+                state.displayAdapter.log(chalk.green(`  ✓ Goal "${state.activeGoal.name}" met!`));
                 // Re-evaluate all goals and pivot to next
                 const allMeasurements = measureGoals(state.goals, state.repoRoot);
                 for (const m of allMeasurements) {
@@ -576,12 +580,12 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                 if (next) {
                     state.activeGoal = state.goals.find(g => g.name === next.goalName) ?? null;
                     state.activeGoalMeasurement = next;
-                    console.log(chalk.cyan(`  → Pivoting to: ${next.goalName} (gap: ${next.gapPercent}%)`));
+                    state.displayAdapter.log(chalk.cyan(`  → Pivoting to: ${next.goalName} (gap: ${next.gapPercent}%)`));
                 }
                 else {
                     const allMet = allMeasurements.every(m => m.met);
                     if (allMet) {
-                        console.log(chalk.green(`  ✓ All goals met!`));
+                        state.displayAdapter.log(chalk.green(`  ✓ All goals met!`));
                     }
                     state.activeGoal = null;
                     state.activeGoalMeasurement = null;
@@ -616,7 +620,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
             }
         }
         else {
-            console.log(chalk.yellow(`  ⚠ Goal "${state.activeGoal.name}" re-measurement failed${error ? `: ${error}` : ''}`));
+            state.displayAdapter.log(chalk.yellow(`  ⚠ Goal "${state.activeGoal.name}" re-measurement failed${error ? `: ${error}` : ''}`));
         }
     }
     // Trajectory cycle budget — abandon if consuming too many cycles.
@@ -630,13 +634,13 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
         if (totalCyclesUsed >= maxCycles) {
             const completedSteps = state.activeTrajectory.steps.filter(s => state.activeTrajectoryState.stepStates[s.id]?.status === 'completed').length;
             const pct = Math.round((completedSteps / state.activeTrajectory.steps.length) * 100);
-            console.log(chalk.yellow(`  Drill: trajectory "${state.activeTrajectory.name}" hit cycle budget (${totalCyclesUsed}/${maxCycles} cycles, ${pct}% complete) — abandoning`));
+            state.displayAdapter.log(chalk.yellow(`  Drill: trajectory "${state.activeTrajectory.name}" hit cycle budget (${totalCyclesUsed}/${maxCycles} cycles, ${pct}% complete) — abandoning`));
             saveTrajectoryState(state.repoRoot, state.activeTrajectoryState);
             try {
                 finishDrillTrajectory(state, 'stalled');
             }
             catch (err) {
-                console.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
+                state.displayAdapter.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
             }
             state.activeTrajectory = null;
             state.activeTrajectoryState = null;
@@ -662,18 +666,18 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                         // Timeout or spawn error
                         allPassed = false;
                         const reason = result.error.message?.includes('TIMEOUT') ? 'timeout (30s)' : result.error.message;
-                        console.log(chalk.yellow(`    ✗ ${cmd} (${reason})`));
+                        state.displayAdapter.log(chalk.yellow(`    ✗ ${cmd} (${reason})`));
                         verificationOutputParts.push(`$ ${cmd}\n${reason}`);
                     }
                     else if (result.status !== 0) {
                         allPassed = false;
                         const stderr = (result.stderr || '').trim().slice(0, 500);
                         const stdout = (result.stdout || '').trim().slice(0, 200);
-                        console.log(chalk.yellow(`    ✗ ${cmd} (exit ${result.status})`));
+                        state.displayAdapter.log(chalk.yellow(`    ✗ ${cmd} (exit ${result.status})`));
                         if (stderr)
-                            console.log(chalk.gray(`      ${stderr.split('\n')[0]}`));
+                            state.displayAdapter.log(chalk.gray(`      ${stderr.split('\n')[0]}`));
                         else if (stdout)
-                            console.log(chalk.gray(`      ${stdout.split('\n')[0]}`));
+                            state.displayAdapter.log(chalk.gray(`      ${stdout.split('\n')[0]}`));
                         verificationOutputParts.push(`$ ${cmd} (exit ${result.status})\n${stderr || stdout}`);
                     }
                 }
@@ -689,12 +693,12 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                         : value <= step.measure.target;
                     stepState.measurement = { value, timestamp: Date.now() };
                     if (!measureMet) {
-                        console.log(chalk.yellow(`    measure: ${value} (target: ${arrow} ${step.measure.target})`));
+                        state.displayAdapter.log(chalk.yellow(`    measure: ${value} (target: ${arrow} ${step.measure.target})`));
                     }
                 }
                 else {
                     measureMet = false;
-                    console.log(chalk.yellow(`    measure failed${error ? `: ${error}` : ''}`));
+                    state.displayAdapter.log(chalk.yellow(`    measure failed${error ? `: ${error}` : ''}`));
                 }
             }
             if (allPassed && measureMet) {
@@ -705,7 +709,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                 stepState.lastVerificationOutput = undefined;
                 const completedCount = state.activeTrajectory.steps.filter(s => state.activeTrajectoryState.stepStates[s.id]?.status === 'completed').length;
                 const totalCount = state.activeTrajectory.steps.length;
-                console.log(chalk.green(`  Trajectory step ${completedCount}/${totalCount} "${step.title}" completed`));
+                state.displayAdapter.log(chalk.green(`  Trajectory step ${completedCount}/${totalCount} "${step.title}" completed`));
                 // Pick next step
                 const next = getTrajectoryNextStep(state.activeTrajectory, state.activeTrajectoryState.stepStates);
                 state.currentTrajectoryStep = next;
@@ -714,16 +718,16 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                     if (state.activeTrajectoryState.stepStates[next.id]) {
                         state.activeTrajectoryState.stepStates[next.id].status = 'active';
                     }
-                    console.log(chalk.cyan(`  -> Next step: ${next.title}`));
+                    state.displayAdapter.log(chalk.cyan(`  -> Next step: ${next.title}`));
                 }
                 else if (trajectoryComplete(state.activeTrajectory, state.activeTrajectoryState.stepStates)) {
                     const fullySucceeded = trajectoryFullySucceeded(state.activeTrajectory, state.activeTrajectoryState.stepStates);
                     const outcome = fullySucceeded ? 'completed' : 'stalled';
                     if (fullySucceeded) {
-                        console.log(chalk.green(`  Trajectory "${state.activeTrajectory.name}" complete!`));
+                        state.displayAdapter.log(chalk.green(`  Trajectory "${state.activeTrajectory.name}" complete!`));
                     }
                     else {
-                        console.log(chalk.yellow(`  Trajectory "${state.activeTrajectory.name}" finished with some failed steps`));
+                        state.displayAdapter.log(chalk.yellow(`  Trajectory "${state.activeTrajectory.name}" finished with some failed steps`));
                     }
                     // Save final state before clearing (so completed status persists on disk)
                     saveTrajectoryState(state.repoRoot, state.activeTrajectoryState);
@@ -732,7 +736,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                             finishDrillTrajectory(state, outcome);
                         }
                         catch (err) {
-                            console.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
+                            state.displayAdapter.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
                         }
                     }
                     state.activeTrajectory = null;
@@ -742,14 +746,14 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                 else {
                     // No next step available but trajectory isn't complete — shouldn't happen now
                     // (failed deps unblock dependents), but handle as fallback
-                    console.log(chalk.yellow(`  Trajectory "${state.activeTrajectory.name}" stalled (remaining steps blocked)`));
+                    state.displayAdapter.log(chalk.yellow(`  Trajectory "${state.activeTrajectory.name}" stalled (remaining steps blocked)`));
                     saveTrajectoryState(state.repoRoot, state.activeTrajectoryState);
                     if (state.drillMode) {
                         try {
                             finishDrillTrajectory(state, 'stalled');
                         }
                         catch (err) {
-                            console.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
+                            state.displayAdapter.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
                         }
                     }
                     state.activeTrajectory = null;
@@ -776,7 +780,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                     const stuckStep = state.activeTrajectory.steps.find(s => s.id === stuckId);
                     const stuckTitle = stuckStep?.title ?? stuckId;
                     const stuckAttempts = stuckStepState?.cyclesAttempted ?? stepState.cyclesAttempted;
-                    console.log(chalk.yellow(`  Trajectory step "${stuckTitle}" stuck after ${stuckAttempts} cycles`));
+                    state.displayAdapter.log(chalk.yellow(`  Trajectory step "${stuckTitle}" stuck after ${stuckAttempts} cycles`));
                     if (stuckStepState) {
                         stuckStepState.status = 'failed';
                         stuckStepState.failureReason = 'max retries exceeded';
@@ -789,18 +793,18 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
                         if (state.activeTrajectoryState.stepStates[next.id]) {
                             state.activeTrajectoryState.stepStates[next.id].status = 'active';
                         }
-                        console.log(chalk.cyan(`  -> Skipping to next step: ${next.title}`));
+                        state.displayAdapter.log(chalk.cyan(`  -> Skipping to next step: ${next.title}`));
                     }
                     else {
                         // No more steps — trajectory is done (all remaining steps failed or completed)
-                        console.log(chalk.yellow(`  Trajectory "${state.activeTrajectory.name}" ended (no remaining steps)`));
+                        state.displayAdapter.log(chalk.yellow(`  Trajectory "${state.activeTrajectory.name}" ended (no remaining steps)`));
                         saveTrajectoryState(state.repoRoot, state.activeTrajectoryState);
                         if (state.drillMode) {
                             try {
                                 finishDrillTrajectory(state, 'stalled');
                             }
                             catch (err) {
-                                console.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
+                                state.displayAdapter.log(chalk.yellow(`  Drill: failed to record trajectory outcome — ${err instanceof Error ? err.message : String(err)}`));
                             }
                         }
                         state.activeTrajectory = null;
@@ -817,7 +821,7 @@ export async function runPostCycleMaintenance(state, scope, isDocsAuditCycle) {
     // Pause between cycles — shorter when trajectory-guided (work is pre-planned)
     if (state.runMode === 'spin' && !state.shutdownRequested) {
         const pauseMs = state.currentTrajectoryStep ? 1000 : 5000;
-        console.log(chalk.gray('Pausing before next cycle...'));
+        state.displayAdapter.log(chalk.gray('Pausing before next cycle...'));
         await sleep(pauseMs);
     }
 }
@@ -903,8 +907,9 @@ function finishDrillTrajectory(state, outcome) {
         }
     }
     const rate = stepsTotal > 0 ? Math.round((stepsCompleted / stepsTotal) * 100) : 0;
-    console.log(chalk.cyan(`  Drill: trajectory ${outcome} (${stepsCompleted}/${stepsTotal} steps, ${rate}% completion)`));
-    console.log(chalk.cyan('  Drill: will survey for next trajectory on next cycle'));
+    state.displayAdapter.log(chalk.cyan(`  Drill: trajectory ${outcome} (${stepsCompleted}/${stepsTotal} steps, ${rate}% completion)`));
+    if (state.options.verbose)
+        state.displayAdapter.log(chalk.cyan('  Drill: will survey for next trajectory on next cycle'));
     // Notify display adapter that trajectory finished (back to idle)
     state.displayAdapter.drillStateChanged({ active: true });
     // Reload learnings immediately so next trajectory generation has fresh context