autodev-cli 1.4.85 → 1.4.93

package/out/taskLoop.js

@@ -61,7 +61,9 @@ const periodicActions_1 = require("./periodicActions");
 const discordGateway_1 = require("./discordGateway");
 const webhookPoller_1 = require("./webhookPoller");
 const emailPoller_1 = require("./emailPoller");
+const modelInfo_1 = require("./core/modelInfo");
 const projectMcp_1 = require("./core/projectMcp");
+const projectSkills_1 = require("./core/projectSkills");
 const configManager_1 = require("./configManager");
 const agentBackup_1 = require("./agentBackup");
 const version_1 = require("./version");
@@ -71,6 +73,7 @@ const version_1 = require("./version");
 const rateLimit_1 = require("./rateLimit");
 const cliExit_1 = require("./cliExit");
 const liveNarration_1 = require("./core/liveNarration");
+const redactSecrets_1 = require("./core/redactSecrets");
 class ContextLengthError extends Error {
     rawMessage;
     constructor(rawMessage) {
@@ -202,6 +205,11 @@ class TaskLoopRunner {
     /** Dispatch attempt counter per task key (id or text). After 3 failed attempts the
      *  loop force-marks the task done so it doesn't block the queue indefinitely. */
     _taskAttempts = new Map();
+    /** Task keys (id or text) flagged as provider hard-failures this session.
+     *  These must NOT be auto-completed by the give_up / stranded-[~] heuristics —
+     *  a blocked task stays [~] + reported failed until it is retried. Cleared when
+     *  a fresh [ ] dispatch of the same task begins (provider presumably recovered). */
+    _blockedTasks = new Set();
     /** Counts completed tasks since the last auto-compact run. */
     _autoCompactCounter = 0;
     /** Counts completed tasks since the last session reset. */
@@ -344,6 +352,7 @@ class TaskLoopRunner {
         this._iterations = 0;
         this._compactedTaskLines.clear();
         this._taskAttempts.clear();
+        this._blockedTasks.clear();
         this._autoCompactCounter = 0;
         this._resetSessionCounter = 0;
         this._profileSentCounter = 0;
@@ -387,7 +396,13 @@ class TaskLoopRunner {
         // `cliVersion` rides in the meta merged into every webhook frame — notably
         // the agent_online (hello) frame — so pixel-office can record which CLI
         // version each agent runs (surfacing stale, steer-incapable agents).
-        this._webhook?.setMeta({ provider: settings.provider, cliVersion: version_1.CLI_VERSION, workDir: root, hostname: this._hostname, gitRepo: this._gitRepo, gitBranch: this._gitBranch });
+        // `model` — the effective friendly model name (Opus 4.8 / kimi-k2.7-code /
+        // grok-code). Resolved from the provider's configured override; undefined
+        // when the provider runs its account default (office gates the field). Rides
+        // in setMeta so it merges into every frame, notably agent_online, where the
+        // office records it against the agent for the per-agent model badge.
+        const effectiveModel = (0, modelInfo_1.resolveConfiguredModel)(settings);
+        this._webhook?.setMeta({ provider: settings.provider, cliVersion: version_1.CLI_VERSION, model: effectiveModel, workDir: root, hostname: this._hostname, gitRepo: this._gitRepo, gitBranch: this._gitBranch });
         this._discordPoller = (settings.discordToken && settings.discordChannelId && settings.discordOwners)
             ? new discordPoller_1.DiscordPoller(settings.discordToken, settings.discordChannelId, settings.discordOwners)
             : null;
@@ -434,6 +449,7 @@ class TaskLoopRunner {
                     // mis-detected as 'claude' by the office's hook-based fallback.
                     provider: this._settings?.provider,
                     cliVersion: version_1.CLI_VERSION,
+                    model: this._settings ? (0, modelInfo_1.resolveConfiguredModel)(this._settings) : undefined,
                     hostname: this._hostname,
                     workDir: this._workspaceRoot ?? '',
                     gitRepo: this._gitRepo,
@@ -485,6 +501,7 @@ class TaskLoopRunner {
             this._webhookPoller.setOnSteer((text, onDelivered) => void this._handleSteer(text, onDelivered));
             this._webhookPoller.setOnCommand((cmd) => this._handleCommand(cmd));
             this._webhookPoller.setOnMcpUpdate((entries) => this._handleMcpUpdate(entries));
+            this._webhookPoller.setOnSkillUpdate((skills) => this._handleSkillUpdate(skills));
             this._webhookPoller.setOnExportRequest((agentId) => void this._handleExportRequest(agentId));
             this._webhookPoller.setOnRestoreRequest((agentId, downloadUrl) => void this._handleRestoreRequest(agentId, downloadUrl));
             this._webhookPoller.setOnExportConfig((exportEnabled, exportDailyBackup, agentId) => this._handleExportConfig(exportEnabled, exportDailyBackup, agentId));
@@ -556,6 +573,7 @@ class TaskLoopRunner {
         this._notifyWebhook('agent_online', {
             provider: settings.provider,
             cliVersion: version_1.CLI_VERSION,
+            model: effectiveModel,
             hostname: this._hostname,
             workDir: root,
             gitRepo: this._gitRepo,
@@ -704,6 +722,44 @@ class TaskLoopRunner {
         }
         void this.restart();
     }
+    /**
+     * Handle skill_update pushed from pixel-office: validate + write the agent's
+     * FULL effective skill set to `.claude/skills/<slug>/SKILL.md`. Skills
+     * live-reload (Claude re-reads them each run), so this does NOT restart the
+     * loop — it just sanitizes, full-replaces on disk, folds a prose block into
+     * AGENTS.md for non-Claude providers, and reports the applied names.
+     */
+    _handleSkillUpdate(skills) {
+        const root = this._workspaceRoot;
+        if (!root)
+            return;
+        // Opt-in gate: remote-supplied skills become instruction files a running
+        // Claude agent live-reads. Ignore unless explicitly enabled, mirroring
+        // mcpUpdateEnabled / enableFileBrowser / gitEnabled.
+        if (!this._settings?.skillUpdateEnabled) {
+            this._cb?.log('🔒 skill_update ignored — skillUpdateEnabled is off (set it in .autodev/settings.json to allow)');
+            return;
+        }
+        this._cb?.log('🧩 skill_update received — validating and writing .claude/skills…');
+        const { safe, rejected } = (0, projectSkills_1.sanitizeRemoteSkills)(root, skills);
+        if (rejected.length) {
+            this._cb?.log(`⚠️ skill_update dropped ${rejected.length} entr${rejected.length === 1 ? 'y' : 'ies'}: ${rejected.map(r => `${r.name} (${r.reason})`).join(', ')}`);
+        }
+        try {
+            // Full-replace: writes the safe set and prunes previously-synced skills
+            // that are gone (even when `safe` is empty — that clears them all).
+            const { written, removed } = (0, projectSkills_1.saveProjectSkills)(root, safe);
+            // Non-Claude providers can't load SKILL.md — fold a prose block into AGENTS.md.
+            if (!(0, projectSkills_1.providerConsumesSkills)(this._settings?.provider)) {
+                (0, projectSkills_1.foldSkillsIntoProfile)(root, safe);
+            }
+            void configManager_1.ConfigManager.reportProjectSkills(root, written, (m) => this._cb?.log(m));
+            this._cb?.log(`✅ skills synced — wrote ${written.length}, removed ${removed.length} (.claude/skills). Live-reloads on the next run — no restart.`);
+        }
+        catch (err) {
+            this._cb?.log(`⚠️ skill update failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /** Handle export_request from pixel-office: create backup zip and upload. */
     async _handleExportRequest(agentId) {
         const root = this._workspaceRoot;
@@ -1162,7 +1218,10 @@ class TaskLoopRunner {
                             if (sessionName) {
                                 ev._session_name = sessionName;
                             }
-                            this._webhookPoller.sendFrame({ type: 'hook_event', data: ev });
+                            // Redact secrets from the whole hook object (tool_input/tool_response/
+                            // assistant narration/file contents) before it leaves the machine —
+                            // this stream is stored + rendered in the office feed/chat.
+                            this._webhookPoller.sendFrame({ type: 'hook_event', data: (0, redactSecrets_1.redactDeep)(ev) });
                         }
                         catch { /* skip malformed lines */ }
                     }
@@ -1382,7 +1441,10 @@ class TaskLoopRunner {
                             this._cb?.log(`⏳ opencode-cli exited cleanly with [~] task — waiting for external response…`);
                         }
                         else {
-                            const stranded = tasks.filter(t => t.status === 'in-progress');
+                            // Exclude tasks flagged as provider hard-failures: those were left
+                            // [~] ON PURPOSE to signal "blocked / needs attention". Auto-marking
+                            // them done here would re-introduce the exact false-green we fixed.
+                            const stranded = tasks.filter(t => t.status === 'in-progress' && !this._blockedTasks.has(t.id ?? t.text));
                             for (const t of stranded) {
                                 // Auto-mark as [x] done rather than resetting to [ ].
                                 // Resetting to [ ] causes an infinite loop: the agent picks it
@@ -1417,6 +1479,10 @@ class TaskLoopRunner {
                 // If the agent hasn't marked it done after 3 attempts, force-mark it
                 // ourselves and move on so the queue doesn't get stuck.
                 const taskKey = task.id ?? task.text;
+                // A fresh [ ] dispatch means this task is being retried — the provider
+                // has presumably recovered, so clear any prior hard-failure flag and let
+                // it complete (or fail) honestly on its own merits this time.
+                this._blockedTasks.delete(taskKey);
                 const attempts = (this._taskAttempts.get(taskKey) ?? 0) + 1;
                 this._taskAttempts.set(taskKey, attempts);
                 const maxAttempts = settings.maxTaskAttempts ?? 3;
@@ -2614,10 +2680,60 @@ class TaskLoopRunner {
                         return;
                     }
                 }
-                const decision = exitHandler?.decide() ?? { kind: 'remind' };
+                // opencode's SDK path surfaces a session.error as an `[ERROR] …` line in
+                // its stdout capture yet still writes exit-code 0 — so the process exit
+                // code alone can't see it. Pass that sentinel through so a session.error
+                // ("No model available" on a copilot-backed free plan, etc.) is treated
+                // as the provider hard-failure it is, not a completed task.
+                const stdoutError = ((isOpenCodeCli || isOpencodeSdk) && /\[ERROR\]/.test(exitStdout))
+                    ? 'session-error'
+                    : null;
+                const decision = exitHandler?.decide({ exitedNonZero, stdoutError })
+                    ?? { kind: 'remind' };
                 if (decision.kind === 'done') {
                     return;
                 }
+                if (decision.kind === 'hard_fail') {
+                    // The PROVIDER hard-failed (reauth / session error / watchdog-no-output
+                    // / crash / model unavailable) and produced no real work. Do NOT mark
+                    // the task [x] done — that would report an outage as SUCCESS. Instead
+                    // flag it [~] blocked, report an honest failure to the office (task_fail
+                    // → TASK_STATE_FAILED, "needs attention") and record a StopFailure hook
+                    // so external monitors see it too. The task stays claimable/retryable.
+                    const reason = decision.reason;
+                    this._failedCount++;
+                    const taskKey = task.id ?? task.text;
+                    this._blockedTasks.add(taskKey);
+                    // Drop the attempt counter so a later retry gets a clean run rather
+                    // than being force-marked done on its first re-dispatch.
+                    this._taskAttempts.delete(taskKey);
+                    this._cb?.log(`⛔ Provider hard-failure (${reason}) — NOT marking done; flagging task as blocked/needs-attention: ${discordLabel(task.text)}`);
+                    await todoWriteManager_1.todoWriter.markInProgress(todoPath, task).catch(() => { });
+                    const duration = Math.round((Date.now() - taskStartTime) / 1000);
+                    const errText = `provider hard-failure: ${reason} (task not completed — needs attention)`;
+                    this._notifyWebhook('task_fail', {
+                        iteration: this._iterations,
+                        task: { text: task.text, id: task.id },
+                        duration,
+                        error: errText,
+                        reason,
+                        workDir: this._workspaceRoot,
+                        gitRepo: this._gitRepo,
+                        gitBranch: this._gitBranch,
+                    });
+                    this._notifyDiscord(`⛔ **Provider failure — task blocked (not done):**\n${discordLabel(task.text)}\n\`${reason}\``);
+                    if (this._workspaceRoot) {
+                        (0, liveNarration_1.appendHookEventLine)(this._workspaceRoot, {
+                            hook_event_name: 'StopFailure', event_type: 'stop_failure',
+                            provider: activeProvider, cwd: this._workspaceRoot, error: reason,
+                            title: 'Provider failure', message: errText, tool_name: '',
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                    cleanup();
+                    resolve();
+                    return;
+                }
                 if (decision.kind === 'deferred') {
                     this._cb?.log(`↩️ CLI exited with task [~] deferred — moving to next pending task: ${discordLabel(task.text)}`);
                     cleanup();