@hamp10/agentforge 0.2.48 → 0.2.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamp10/agentforge",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "description": "AgentForge worker — connect your machine to agentforge.ai",
   "type": "module",
   "bin": {

package/scripts/check-task-semantics.js

@@ -549,6 +549,44 @@ try {
     /The task is:|Delete and rebuild both/i,
     'missing-target retries should not put the original reset-heavy task text at the top of the retry prompt'
   );
+  assert.throws(
+    () => cli._guardDirectFileWritePath(
+      path.join(fixture.repo, 'public_html', 'domains', 'alpha.html'),
+      fixture.repo,
+      { task: incompleteRepairLead }
+    ),
+    /focused retry pass/i,
+    'direct writes should block already-touched scoped pages during a missing-target retry pass'
+  );
+  assert.doesNotThrow(
+    () => cli._guardDirectFileWritePath(
+      path.join(fixture.repo, 'public_html', 'domains', 'beta.html'),
+      fixture.repo,
+      { task: incompleteRepairLead }
+    ),
+    'direct writes should allow the missing scoped page during a missing-target retry pass'
+  );
+  const visualRepairLead = worker._formatVisualRepairTaskLead(
+    'Work on the Example.com listing pages for Alpha.ai and Beta.ai. Make both visually polished.',
+    'beta-ai: Visual warning: heading is clipped.'
+  );
+  assert.throws(
+    () => cli._guardDirectFileWritePath(
+      path.join(fixture.repo, 'public_html', 'domains', 'alpha.html'),
+      fixture.repo,
+      { task: visualRepairLead }
+    ),
+    /focused retry pass/i,
+    'direct writes should block non-failing scoped pages during a focused visual repair pass'
+  );
+  assert.doesNotThrow(
+    () => cli._guardDirectFileWritePath(
+      path.join(fixture.repo, 'public_html', 'domains', 'beta.html'),
+      fixture.repo,
+      { task: visualRepairLead }
+    ),
+    'direct writes should allow the failing scoped page during a focused visual repair pass'
+  );
   assert.equal(
     worker._formatRepeatedVisualRepairNudge(2),
     '',

package/src/OpenClawCLI.js

@@ -914,6 +914,24 @@ export class OpenClawCLI extends EventEmitter {
     return err;
   }
 
+  _directFocusedRetryAllowedSlugs(task) {
+    const text = String(task || '');
+    const patterns = [
+      /missing-target pass for target page\(s\) not yet changed in the current diff:\s*([^\n.]+)/i,
+      /visual repair pass for currently failing target page\(s\):\s*([^\n.]+)/i,
+    ];
+    for (const pattern of patterns) {
+      const match = text.match(pattern);
+      if (!match) continue;
+      const slugs = String(match[1] || '')
+        .split(/[,;]/)
+        .map(item => scopeSlug(item.trim()))
+        .filter(Boolean);
+      if (slugs.length > 0) return new Set(slugs);
+    }
+    return null;
+  }
+
   _isNestedProjectCopyPath(filePath, workDir) {
     const relative = path.relative(workDir, filePath);
     if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return false;
@@ -1048,6 +1066,20 @@ export class OpenClawCLI extends EventEmitter {
     if (!this._directTaskScopeAllowsPath(filePath, workDir, options.task)) {
       throw this._directScopeViolationError(this._formatDirectScopeError(filePath, workDir, options.task));
     }
+    const focusedRetrySlugs = this._directFocusedRetryAllowedSlugs(options.task);
+    if (focusedRetrySlugs && slugs.length > 0) {
+      const matchedScopedSlugs = this._directScopeSlugsMatchingText(lowerRelativePath, slugs);
+      const matchesFocusedSlug = matchedScopedSlugs.some(slug => focusedRetrySlugs.has(slug));
+      if (matchedScopedSlugs.length > 0 && !matchesFocusedSlug) {
+        throw this._directScopeViolationError([
+          'Refusing to rewrite an already-addressed scoped target during a focused retry pass.',
+          `Requested path: ${relativePath}`,
+          `Current retry target(s): ${[...focusedRetrySlugs].join(', ')}.`,
+          `Path appears to belong to: ${matchedScopedSlugs.join(', ')}.`,
+          'Continue from the current repo state and edit the focused target page(s) named by the retry instruction, then verify every requested target page locally.',
+        ].join(' '));
+      }
+    }
     const collectionViolation = this._directNewHtmlPageCollectionViolation(
       filePath,
       workDir,
@@ -1788,7 +1820,7 @@ export class OpenClawCLI extends EventEmitter {
     if (!sessionFilePath || !existsSync(sessionFilePath)) return null;
     try {
       const lines = readFileSync(sessionFilePath, 'utf8').split('\n');
-      let input = 0, output = 0, costUsd = 0;
+      let input = 0, output = 0, costUsd = 0, hasCost = false;
       for (const line of lines) {
         if (!line.trim()) continue;
         try {
@@ -1798,14 +1830,26 @@ export class OpenClawCLI extends EventEmitter {
             output += entry.message.usage.output || 0;
             // openclaw writes exact cost.total — use it directly instead of re-calculating
             if (entry.message.usage.cost?.total != null) {
-              costUsd += entry.message.usage.cost.total;
+              const costTotal = Number(entry.message.usage.cost.total);
+              if (Number.isFinite(costTotal) && costTotal >= 0) {
+                costUsd += costTotal;
+                hasCost = true;
+              }
             }
           }
         } catch { /* skip malformed lines */ }
       }
       if (input > 0 || output > 0) {
         console.log(`[session-usage] Read from JSONL: input=${input} output=${output} cost=$${costUsd.toFixed(6)}`);
-        return { input_tokens: input, output_tokens: output, cost_usd: costUsd > 0 ? costUsd : undefined };
+        return {
+          input_tokens: input,
+          output_tokens: output,
+          ...(hasCost ? {
+            cost_usd: costUsd,
+            cost_source: 'provider_reported',
+            cost_accuracy: 'exact',
+          } : {}),
+        };
       }
       return null;
     } catch (e) {

package/src/worker.js

@@ -3890,7 +3890,10 @@ export class AgentForgeWorker extends EventEmitter {
       let uiRepairNudgeCount = 0;
       let taskResult;
       let iterationMessage = finalMessage;
-      let totalUsage = { input_tokens: 0, output_tokens: 0, cost_usd: 0 };
+      let totalUsage = { input_tokens: 0, output_tokens: 0 };
+      let totalUsageCostUsd = 0;
+      let usageSegments = 0;
+      let usageCostSegments = 0;
       // Fallback tracking: used at most once per task
       let usedFallback = false;
       let toolFailureRetryCount = 0;
@@ -4175,10 +4178,19 @@ export class AgentForgeWorker extends EventEmitter {
           break;
         }
         if (taskResult?.usage) {
-          totalUsage.input_tokens += taskResult.usage.input_tokens || 0;
-          totalUsage.output_tokens += taskResult.usage.output_tokens || 0;
+          const inputTokens = Number(taskResult.usage.input_tokens || 0);
+          const outputTokens = Number(taskResult.usage.output_tokens || 0);
+          totalUsage.input_tokens += Number.isFinite(inputTokens) ? inputTokens : 0;
+          totalUsage.output_tokens += Number.isFinite(outputTokens) ? outputTokens : 0;
+          if ((inputTokens > 0 || outputTokens > 0) || taskResult.usage.cost_usd != null) {
+            usageSegments += 1;
+          }
           if (taskResult.usage.cost_usd != null) {
-            totalUsage.cost_usd += taskResult.usage.cost_usd;
+            const costUsd = Number(taskResult.usage.cost_usd);
+            if (Number.isFinite(costUsd) && costUsd >= 0) {
+              totalUsageCostUsd += costUsd;
+              usageCostSegments += 1;
+            }
           }
         }
 
@@ -5065,7 +5077,12 @@ export class AgentForgeWorker extends EventEmitter {
         console.log(`[${taskId}] ℹ️ Task succeeded with no text output — using default completion message`);
       }
       console.log(`[${taskId}] 📤 finalOutput="${finalOutput.slice(0,100)}" response=${finalOutput ? `"${finalOutput.slice(0,80)}"` : 'undefined'}`);
-      const hasUsage = totalUsage.input_tokens > 0 || totalUsage.output_tokens > 0 || totalUsage.cost_usd > 0;
+      if (usageSegments > 0 && usageCostSegments === usageSegments) {
+        totalUsage.cost_usd = totalUsageCostUsd;
+        totalUsage.cost_source = 'provider_reported';
+        totalUsage.cost_accuracy = 'exact';
+      }
+      const hasUsage = totalUsage.input_tokens > 0 || totalUsage.output_tokens > 0 || totalUsage.cost_usd != null;
       const completionMessage = {
         type: 'task_complete',
         taskId,