@intrect/openswarm 0.9.3 → 0.10.0

package/dist/automation/autonomousRunner.js

@@ -1,8 +1,8 @@
 // OpenSwarm - Autonomous Runner
 // Heartbeat → Decision → Execution → Report
 import { Cron } from 'croner';
-import { loadTaskState, saveTaskState, buildProjectsInfo, appendPipelineHistory, getPipelineHistory, incrementRejection, clearRejection, isRejectionLimitReached, canRetryNow, setRetryTime, clearRetryTime, formatRetryTime, getDailyPaceInfo, recordProjectCompletion, canProjectAcceptTask, getProjectWindowCount, } from './runnerState.js';
-import { getDecisionEngine, } from '../orchestration/decisionEngine.js';
+import { loadTaskState, saveTaskState, buildProjectsInfo, appendPipelineHistory, getPipelineHistory, incrementRejection, clearRejection, isRejectionLimitReached, canRetryNow, setRetryTime, clearRetryTime, formatRetryTime, getDailyPaceInfo, recordProjectCompletion, canProjectAcceptTask, getProjectWindowCount, loadProjectSelection, saveProjectSelection, } from './runnerState.js';
+import { getDecisionEngine, classifyStuck, } from '../orchestration/decisionEngine.js';
 // ExecutorResult used via execution.reportExecutionResult
 import { checkWorkAllowed } from '../support/timeWindow.js';
 import { recordTaskOutcome } from '../memory/repoKnowledge.js';
@@ -14,12 +14,14 @@ import * as execution from './runnerExecution.js';
 import { reportToDiscord, fetchLinearTasks, getTaskSource } from './runnerExecution.js';
 import { t } from '../locale/index.js';
 import { broadcastEvent } from '../core/eventHub.js';
+import { writeProviderOverride } from '../core/providerOverride.js';
+import { getTaskState } from '../taskState/store.js';
 import { pruneWorktrees } from '../support/worktreeManager.js';
 import { loadRepoMetadata } from '../support/repoMetadata.js';
+import { STUCK_LABEL } from '../linear/index.js';
 import { refreshGraph, toProjectSlug } from '../knowledge/index.js';
 import { checkAllMonitors, getActiveMonitors } from './longRunningMonitor.js';
 import { detectFileConflicts } from '../orchestration/conflictDetector.js';
-import { checkQuotaAllowance } from '../support/quotaTracker.js';
 // Re-export types and integration setters (used by service.ts)
 export { setNotifier, setTaskSource } from './runnerExecution.js';
 let runnerInstance = null;
@@ -35,8 +37,14 @@ export class AutonomousRunner {
     };
     // Heartbeat concurrency guard
     _heartbeatRunning = false;
-    // Explicitly enabled project paths (allow-list; empty = nothing runs)
+    // Explicitly enabled project paths (allow-list; empty = nothing runs ONLY once
+    // the selection has been touched — see projectSelectionTouched).
     enabledProjects = new Set();
+    // Whether the user has explicitly enabled/disabled any project (dashboard/CLI).
+    // Before this, an empty enabledProjects means "no selection yet → all allowed
+    // projects run" (legacy fallback). After, an empty set means "nothing runs" —
+    // so disabling every project actually stops the daemon. (INT-2207)
+    projectSelectionTouched = false;
     /**
      * macOS (APFS default) and Windows have case-insensitive filesystems by
      * default, so `/Users/x/dev/AnalogModeling` and `/Users/x/dev/analogModeling`
@@ -64,6 +72,21 @@ export class AutonomousRunner {
         }
         return false;
     }
+    /**
+     * Whether to apply the enabledProjects allow-list. True once the user has made
+     * an explicit selection (touched), OR while any project is enabled. Empty +
+     * untouched stays the legacy "run all allowed projects" fallback. (INT-2207)
+     */
+    shouldFilterByEnabled() {
+        return this.projectSelectionTouched || this.enabledProjects.size > 0;
+    }
+    /** Persist the project selection so it survives a restart. No-op under dryRun
+     * (tests) to avoid touching the real ~/.openswarm. (INT-2208) */
+    persistSelection() {
+        if (this.config.dryRun)
+            return;
+        saveProjectSelection({ enabled: [...this.enabledProjects], touched: this.projectSelectionTouched });
+    }
     // Last fetched Linear tasks (for dashboard display)
     lastFetchedTasks = [];
     // Cache: linearProjectName → resolvedLocalPath (populated during task execution)
@@ -77,6 +100,13 @@ export class AutonomousRunner {
     failedTaskCounts = new Map();
     failedTaskRetryTimes = new Map(); // issueId → next retry timestamp (ms)
     static MAX_RETRY_COUNT = 4; // Increased from 2 to allow more retries with backoff
+    // Rate-limit hold: epoch ms until which all task execution is paused.
+    // Set when any adapter returns a 429 / usage_limit_reached response (INT-1906).
+    rateLimitUntil = 0;
+    // Issues whose Linear project can't be mapped to a local repo path. Recorded on
+    // the first resolve failure so they aren't re-picked every heartbeat (which
+    // starved other actionable tasks — they were top-priority but never runnable). (INT-1875)
+    unresolvableIssueIds = new Set();
     get taskStateRef() {
         return {
             completedTaskIds: this.completedTaskIds,
@@ -103,6 +133,13 @@ export class AutonomousRunner {
     constructor(config) {
         this.config = config;
         this.loadTaskState(); // Restore completed/failed task IDs from disk
+        // Restore the persisted project selection so "disable all" survives a daemon
+        // restart. Skipped under dryRun (tests) so the real ~/.openswarm isn't touched. (INT-2208)
+        if (!config.dryRun) {
+            const sel = loadProjectSelection();
+            this.enabledProjects = new Set(sel.enabled);
+            this.projectSelectionTouched = sel.touched;
+        }
         this.engine = getDecisionEngine({
             allowedProjects: config.allowedProjects,
             linearTeamId: config.linearTeamId,
@@ -113,9 +150,11 @@ export class AutonomousRunner {
             includeBacklog: config.includeBacklog,
         });
         // Initialize TaskScheduler
+        // Same-repo parallelism is opt-in via config (default true) but the scheduler
+        // force-disables it unless worktreeMode is on — see TaskScheduler guard. (INT-1975)
         this.scheduler = initScheduler({
             maxConcurrent: config.maxConcurrentTasks ?? 1,
-            allowSameProjectConcurrent: false,
+            allowSameProjectConcurrent: config.allowSameProjectConcurrent ?? true,
             worktreeMode: config.worktreeMode ?? false,
         });
         // Set up scheduler event handling
@@ -198,8 +237,55 @@ export class AutonomousRunner {
             }
             this.scheduleNextHeartbeat();
         });
+        this.scheduler.on('cancelled', async ({ task, result }) => {
+            const taskCtx = this.formatTaskContext(task);
+            console.log(`[Scheduler] Task cancelled: ${taskCtx} ${task.title}`);
+            broadcastEvent({ type: 'task:completed', data: { taskId: task.id, success: false, duration: result.totalDuration } });
+            this.recordPipelineHistory(task, result);
+            await execution.syncCancellationState(task);
+            // Keep parity with the completed/failed handlers: kick the next heartbeat
+            // so discovery resumes immediately instead of waiting for the next cron
+            // tick (matters in serial mode, where slotFreed/runAvailableTasks is a no-op).
+            this.scheduleNextHeartbeat();
+        });
         this.scheduler.on('failed', async ({ task, result }) => {
             const taskCtx = this.formatTaskContext(task);
+            // Rate-limited: pause execution until the quota resets. Do NOT count it as a
+            // task failure, run the rejection/block path, or post a Linear comment —
+            // that is exactly the retry-spam this issue fixes. (INT-1906)
+            if (result.finalStatus === 'rate_limited') {
+                const resetsAt = result.rateLimitResetsAt ?? Date.now() + 60_000;
+                this.rateLimitUntil = resetsAt;
+                const waitSec = Math.max(0, Math.ceil((resetsAt - Date.now()) / 1000));
+                const resetsLabel = new Date(resetsAt).toISOString();
+                console.warn(`[Scheduler] Rate limit hit for ${taskCtx} — pausing until ${resetsLabel} (~${waitSec}s)`);
+                broadcastEvent({
+                    type: 'log',
+                    data: { taskId: task.issueId || task.id, stage: 'rate_limit', line: `⏸ Rate limited — pausing ~${waitSec}s (until ${resetsLabel})` },
+                });
+                return;
+            }
+            // Infra/CLI failure: the worker/reviewer never actually ran (non-zero exit,
+            // auth expiry, spawn, timeout). This is NOT a task failure — do NOT increment
+            // the rejection/failure counters that mark an issue durably STUCK. Backoff-
+            // retry instead; the operator fixes the root cause (e.g. re-auth) and the task
+            // resumes on its own. This is what kept completable tasks (worker had already
+            // edited files) STUCK in production. (INT-2010)
+            if (result.finalStatus === 'infra_error') {
+                const detail = result.workerResult?.error || result.reviewResult?.feedback || 'infra/CLI execution error';
+                if (task.issueId) {
+                    // Fixed mid-range backoff — we intentionally don't bump failure counts,
+                    // so there's no attempt number to scale by.
+                    const nextRetryTime = setRetryTime(task.issueId, 3, this.failedTaskRetryTimes);
+                    this.saveTaskState();
+                    console.warn(`[Scheduler] Infra error for ${taskCtx} (NOT counted toward STUCK) — backoff retry ${formatRetryTime(nextRetryTime)}: ${detail}`);
+                }
+                else {
+                    console.warn(`[Scheduler] Infra error for ${taskCtx} (NOT counted toward STUCK): ${detail}`);
+                }
+                this.scheduleNextHeartbeat();
+                return;
+            }
             console.log(`[Scheduler] Task failed: ${taskCtx} ${task.title}`);
             broadcastEvent({ type: 'task:completed', data: { taskId: task.id, success: false, duration: result.totalDuration } });
             this.recordPipelineHistory(task, result);
@@ -225,11 +311,9 @@ export class AutonomousRunner {
                     this.saveTaskState();
                     try {
                         await execution.syncFailureState(task, `Max rejection limit reached (${rejectionCount} attempts): ${feedback}`);
-                        await getTaskSource()?.logBlocked(task.issueId, 'autonomous-runner', `⚠️ **Max rejection limit reached (${rejectionCount} attempts)**\n\n` +
-                            `This task has been rejected ${rejectionCount} times by the reviewer and requires manual intervention.\n\n` +
-                            `**Latest rejection reason:**\n${feedback}\n\n` +
-                            `**Action required:** Please review the task requirements and code manually, or adjust the task scope.`);
-                        console.log(`[Scheduler] Issue ${task.issueId} permanently blocked (max rejections reached)`);
+                        await getTaskSource()?.logStuck(task.issueId, 'autonomous-runner', `Rejected ${rejectionCount} times by the reviewer — automatic retries exhausted.\n\n` +
+                            `**Latest rejection reason:**\n${feedback}`);
+                        console.log(`[Scheduler] Issue ${task.issueId} marked STUCK (max rejections reached)`);
                     }
                     catch (err) {
                         console.error(`[Scheduler] Failed to update issue state:`, err);
@@ -262,11 +346,17 @@ export class AutonomousRunner {
                     this.completedTaskIds.add(task.issueId); // Prevent re-selection
                     clearRetryTime(task.issueId, this.failedTaskRetryTimes); // Clear retry time
                     this.saveTaskState();
-                    console.log(`[Scheduler] Task failure count: ${count}/${AutonomousRunner.MAX_RETRY_COUNT} for ${taskCtx} — BLOCKED`);
+                    console.log(`[Scheduler] Task failure count: ${count}/${AutonomousRunner.MAX_RETRY_COUNT} for ${taskCtx} — STUCK`);
+                    // Surface the underlying failure (worker CLI error / review feedback) so the
+                    // stuck comment is actionable instead of an opaque "failed N times".
+                    const failureDetail = result.workerResult?.error
+                        || result.reviewResult?.feedback
+                        || 'No error detail captured (worker produced no output).';
                     try {
-                        await execution.syncFailureState(task, `Autonomous execution failed ${count} times`);
-                        await getTaskSource()?.logBlocked(task.issueId, 'autonomous-runner', `Autonomous execution failed ${count} times. Moving to Blocked for manual review.`);
-                        console.log(`[Scheduler] Issue ${task.issueId} marked as Todo (blocked) (max retries exceeded)`);
+                        await execution.syncFailureState(task, `Autonomous execution failed ${count} times: ${failureDetail}`);
+                        await getTaskSource()?.logStuck(task.issueId, 'autonomous-runner', `Autonomous execution failed ${count} times in a row — automatic retries exhausted.\n\n` +
+                            `**Last failure:**\n${failureDetail}`);
+                        console.log(`[Scheduler] Issue ${task.issueId} marked STUCK (max retries exceeded)`);
                     }
                     catch (err) {
                         console.error(`[Scheduler] Failed to update issue state:`, err);
@@ -305,11 +395,14 @@ export class AutonomousRunner {
     }
     filterAlreadyProcessed(tasks) {
         let recovered = 0;
+        let stuckSkipped = 0;
         let backoffSkipped = 0;
         let noProject = 0;
-        const recoverableStates = new Set(['Todo', 'In Progress', 'In Review']);
+        let unresolvable = 0;
+        const toUnstick = [];
         const filtered = tasks.filter(task => {
             const id = task.issueId || task.id;
+            const isStuck = task.labels?.includes(STUCK_LABEL) ?? false;
             // No Linear project → can't be routed to a repo. Drop here (quietly, once per
             // heartbeat) instead of letting a whole batch of project-less Todos reach the
             // per-task selector and spam "No repo mapped to ... undefined" every cycle.
@@ -317,24 +410,54 @@ export class AutonomousRunner {
                 noProject++;
                 return false;
             }
+            // Project resolved to no local repo on a previous heartbeat → don't re-pick
+            // it (it would starve runnable tasks behind it). (INT-1875)
+            if (this.unresolvableIssueIds.has(id)) {
+                unresolvable++;
+                return false;
+            }
             // Check rejection limit first
             if (isRejectionLimitReached(id)) {
                 return false; // Skip tasks that hit max rejection limit
             }
-            // Recover issues in active states from completed/failed list
-            // (user or system intentionally moved back to active, so retry)
-            if (recoverableStates.has(task.linearState || '') && (this.completedTaskIds.has(id) || (this.failedTaskCounts.get(id) ?? 0) >= AutonomousRunner.MAX_RETRY_COUNT)) {
+            // Stuck handling (INT-1908): a permanently-blocked issue is parked in Backlog
+            // with the `swarm:stuck` label and must NOT be retried automatically. The
+            // recovery branch only fires when the user pulls the issue back to an active
+            // state — the previous code re-selected it every heartbeat because blocking
+            // left it in Todo (a recoverable state), which the recovery branch then
+            // mistook for deliberate user intervention.
+            const hasFailureHistory = this.completedTaskIds.has(id) || (this.failedTaskCounts.get(id) ?? 0) >= AutonomousRunner.MAX_RETRY_COUNT;
+            const stuckDecision = classifyStuck({ isStuck, linearState: task.linearState, hasFailureHistory });
+            if (stuckDecision === 'recover') {
                 this.completedTaskIds.delete(id);
                 this.failedTaskCounts.delete(id);
                 clearRejection(id); // Clear rejection count on recovery
                 clearRetryTime(id, this.failedTaskRetryTimes); // Clear retry backoff time
+                if (isStuck)
+                    toUnstick.push(id); // strip the stuck label so it is not re-skipped
                 recovered++;
                 return true;
             }
+            if (stuckDecision === 'skip-stuck') {
+                // Durable across restarts: the label lives on the Linear issue, not in the
+                // in-memory counters that a restart would lose.
+                stuckSkipped++;
+                return false;
+            }
             if (this.completedTaskIds.has(id))
                 return false;
             if ((this.failedTaskCounts.get(id) ?? 0) >= AutonomousRunner.MAX_RETRY_COUNT)
                 return false;
+            // External-claim guard (INT-1979 dup): an issue set to 'In Progress' that THIS
+            // daemon never claimed is owned by a human or another agent — picking it up
+            // would re-decompose work someone is already doing (that spawned duplicate
+            // INT-1980 sub-issues + a redundant PR). markTaskInProgress writes
+            // execution.status='in_progress' when WE claim, so our own in-flight work
+            // (incl. resumption after a restart) still passes; a bare Linear 'In Progress'
+            // with no local claim record is skipped.
+            if (task.linearState === 'In Progress' && getTaskState(id)?.execution?.status !== 'in_progress') {
+                return false;
+            }
             // Check if task is in exponential backoff period
             if (!canRetryNow(id, this.failedTaskRetryTimes)) {
                 backoffSkipped++;
@@ -342,6 +465,14 @@ export class AutonomousRunner {
             }
             return true;
         });
+        // Strip the stuck label from issues the user pulled back (fire-and-forget — a
+        // failed unstick just means the next heartbeat tries again).
+        for (const id of toUnstick) {
+            getTaskSource()?.unstick(id).catch(err => console.warn(`[AutonomousRunner] Failed to clear stuck label for ${id}:`, err));
+        }
+        if (stuckSkipped > 0) {
+            this.syslog(`🛑 Skipped ${stuckSkipped} stuck issue(s) (retries exhausted — remove the \`${STUCK_LABEL}\` label or move to Todo to retry)`);
+        }
         if (recovered > 0) {
             this.saveTaskState();
             this.syslog(`♻ Recovered ${recovered} Todo issues from completed/failed/rejected list`);
@@ -352,6 +483,9 @@ export class AutonomousRunner {
         if (noProject > 0) {
             this.syslog(`— Skipped ${noProject} issue(s) with no Linear project (assign a project in Linear to enable)`);
         }
+        if (unresolvable > 0) {
+            this.syslog(`— Skipped ${unresolvable} issue(s) whose Linear project maps to no local repo (fix the project or add the repo)`);
+        }
         return filtered;
     }
     /**
@@ -531,16 +665,20 @@ export class AutonomousRunner {
                 return;
             }
             this.syslog('✓ Time window: allowed');
-            // 1.5 Quota gate — skip heartbeat if Claude Max quota is too high
-            const quotaCheck = await checkQuotaAllowance(80);
-            if (!quotaCheck.allowed) {
-                console.log(`[AutonomousRunner] Quota gate: SKIP — ${quotaCheck.reason}`);
-                broadcastEvent({ type: 'log', data: { taskId: 'system', stage: 'quota', line: `⏸ ${quotaCheck.reason}` } });
+            // 1.2 Rate-limit hold — skip the heartbeat while a 429 pause is still active.
+            // Cleared implicitly once the clock passes rateLimitUntil. (INT-1906)
+            if (Date.now() < this.rateLimitUntil) {
+                const remainSec = Math.max(0, Math.ceil((this.rateLimitUntil - Date.now()) / 1000));
+                const resetsLabel = new Date(this.rateLimitUntil).toISOString();
+                console.log(`[AutonomousRunner] Rate limit hold active — ${remainSec}s remaining (until ${resetsLabel})`);
+                this.syslog(`⏸ Rate limit hold: ~${remainSec}s remaining`);
+                broadcastEvent({ type: 'log', data: { taskId: 'system', stage: 'rate_limit', line: `⏸ Rate limit hold: ~${remainSec}s remaining` } });
                 return;
             }
-            if (quotaCheck.utilization !== undefined && quotaCheck.utilization > 60) {
-                console.log(`[AutonomousRunner] Quota warning: ${quotaCheck.utilization.toFixed(0)}% utilization`);
-            }
+            // 1.5 Quota gate (removed) — was a Claude Max quota check (api.anthropic.com
+            // /oauth/usage). OpenSwarm runs codex-responses now, not claude -p, so a Claude
+            // quota gate is irrelevant; it only spammed 401s and could wrongly skip codex
+            // work. codex-responses self-protects via RateLimitError (scheduler pause).
             // 1.6 Pace gate (removed)
             // The 5h rolling window cap (globalCap = projects × dailyTaskCap) and
             // turbo-mode multiplier used to gate heartbeat here. Both were removed
@@ -619,7 +757,7 @@ export class AutonomousRunner {
         // Only execute Todo tasks; Backlog is fetched for dashboard display only
         const executableTasks = tasks.filter(t => t.linearState !== 'Backlog');
         let tasksForEngine = executableTasks;
-        if (this.enabledProjects.size > 0) {
+        if (this.shouldFilterByEnabled()) {
             // Explicit repo↔Linear mapping — match fetched issues to repos by the Linear
             // projectId the user picked in `openswarm add` (written to <repo>/openswarm.json),
             // NOT by guessing from the repo directory name. Built fresh each cycle so a
@@ -685,6 +823,8 @@ export class AutonomousRunner {
             const projectPath = await this.resolveProjectPath(task);
             if (!projectPath) {
                 this.syslog(`✗ Cannot resolve project path for "${task.linearProject?.name || task.title}" — skipping`);
+                // Record so it isn't re-picked every heartbeat (starvation). (INT-1875)
+                this.unresolvableIssueIds.add(task.issueId || task.id);
                 continue;
             }
             if (task.linearProject?.name) {
@@ -694,7 +834,7 @@ export class AutonomousRunner {
                 this.syslog(`  Project busy: ${projectPath}`);
                 continue;
             }
-            if (this.enabledProjects.size > 0 && !this.isProjectEnabled(projectPath)) {
+            if (this.shouldFilterByEnabled() && !this.isProjectEnabled(projectPath)) {
                 this.syslog(`  Project not enabled: ${projectPath}`);
                 continue;
             }
@@ -777,11 +917,16 @@ export class AutonomousRunner {
         if (!projectPath) {
             const errorMsg = `Failed to resolve project path for "${task.linearProject?.name || task.title}"`;
             console.error(`[AutonomousRunner] ${errorMsg}`);
+            // Record so this issue isn't re-picked every heartbeat (it would starve
+            // runnable tasks behind it). Cleared on restart. (INT-1875)
+            this.unresolvableIssueIds.add(task.issueId || task.id);
             await reportToDiscord(t('runner.projectMappingFailed', { title: task.title, project: task.linearProject?.name || 'unknown' }));
+            // Move on to the next actionable task instead of ending the heartbeat here.
+            this.scheduleNextHeartbeat();
             return;
         }
         // Skip if project is not in enabled list (allow-list; empty = nothing runs)
-        if (this.enabledProjects.size > 0 && !this.isProjectEnabled(projectPath)) {
+        if (this.shouldFilterByEnabled() && !this.isProjectEnabled(projectPath)) {
             console.log(`[AutonomousRunner] Project not enabled, skipping: ${projectPath}`);
             return;
         }
@@ -814,6 +959,18 @@ export class AutonomousRunner {
         }
         // Single execution (legacy)
         const result = await this.executePipeline(task, projectPath);
+        // Rate-limited: pause until quota resets. Return before any Discord/Linear
+        // reporting or state change — no failure count, no card spam. Same as the
+        // scheduler 'failed' handler's rate_limited branch. (INT-1906)
+        if (result.finalStatus === 'rate_limited') {
+            const resetsAt = result.rateLimitResetsAt ?? Date.now() + 60_000;
+            this.rateLimitUntil = resetsAt;
+            const waitSec = Math.max(0, Math.ceil((resetsAt - Date.now()) / 1000));
+            const resetsLabel = new Date(resetsAt).toISOString();
+            console.warn(`[AutonomousRunner] Rate limit hit for ${this.formatTaskContext(task)} — pausing until ${resetsLabel} (~${waitSec}s)`);
+            broadcastEvent({ type: 'log', data: { taskId: task.issueId || task.id, stage: 'rate_limit', line: `⏸ Rate limited — pausing ~${waitSec}s (until ${resetsLabel})` } });
+            return;
+        }
         await reportToDiscord(formatPipelineResultEmbed(result));
         // Update Linear issue state
         if (task.issueId) {
@@ -1050,6 +1207,26 @@ export class AutonomousRunner {
         if (this.config.reviewerModel) {
             this.config.reviewerModel = mapModelForProvider(this.config.reviewerModel, 'reviewer');
         }
+        // jobProfiles ALSO pin per-role models (config's light/heavy → e.g. qwen), and getModelForRole
+        // gives the profile model precedence over defaultRoles. Remapping only defaultRoles left every
+        // estimate-matched task on its old provider's model → "I switched to Codex but it still uses the
+        // old provider". Remap the profiles too: an incompatible id becomes undefined so the adapter
+        // falls back to its OWN default model.
+        if (this.config.jobProfiles) {
+            for (const profile of this.config.jobProfiles) {
+                if (!profile.roles)
+                    continue;
+                for (const role of Object.keys(profile.roles)) {
+                    const mapped = mapModelForProvider(profile.roles[role], role);
+                    if (mapped === undefined)
+                        delete profile.roles[role];
+                    else
+                        profile.roles[role] = mapped;
+                }
+            }
+        }
+        // Persist the choice so a daemon restart keeps it (in-memory switch was lost every restart).
+        writeProviderOverride(adapter);
         console.log(`[AutonomousRunner] Provider switched: ${adapter}`);
     }
     pauseScheduler() { this.scheduler.pause(); }
@@ -1072,6 +1249,7 @@ export class AutonomousRunner {
         });
     }
     disableProject(projectPath) {
+        this.projectSelectionTouched = true; // empty set now means "nothing runs" (INT-2207)
         this.enabledProjects.delete(projectPath);
         console.log(`[AutonomousRunner] Project disabled: ${projectPath}`);
         // Disabling gates new selection AND cancels any in-flight pipeline for this
@@ -1080,10 +1258,21 @@ export class AutonomousRunner {
         if (cancelled > 0) {
             this.syslog(`⏹ Cancelled ${cancelled} in-flight task(s) for disabled project ${projectPath.split('/').pop()}`);
         }
+        this.persistSelection();
     }
     enableProject(projectPath) {
+        this.projectSelectionTouched = true; // explicit selection from here on (INT-2207)
         this.enabledProjects.add(projectPath);
+        // Enabling a repo (via `openswarm add` / the dashboard) must also ALLOW it:
+        // resolveProjectPath only reads a repo's openswarm.json for paths in
+        // allowedProjects, so an enabled-but-not-allowed repo never resolves
+        // ("No repo mapped"). Keep config + DecisionEngine in sync. (INT-1970)
+        const allowed = this.config.allowedProjects ?? [];
+        if (!allowed.includes(projectPath)) {
+            this.updateAllowedProjects([...allowed, projectPath]);
+        }
         console.log(`[AutonomousRunner] Project enabled: ${projectPath}`);
+        this.persistSelection();
     }
     /** Get all currently enabled project paths */
     getEnabledProjects() {