npm - @hamp10/agentforge - Versions diffs - 0.2.49 → 0.2.51 - Mend

@hamp10/agentforge 0.2.49 → 0.2.51

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/package.json +1 -1
package/scripts/check-task-semantics.js +11 -2
package/src/OpenClawCLI.js +16 -4
package/src/worker.js +67 -12

package/package.json CHANGED Viewed

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

package/scripts/check-task-semantics.js CHANGED Viewed

@@ -291,9 +291,18 @@ try {
   );
   git(fixture.repo, ['restore', '--', nestedAlphaRel]);
   const untrackedGammaRel = 'public_html/domains/gamma.html';
+  writeFileSync(path.join(fixture.repo, untrackedGammaRel), '');
+  assert.match(
+    worker._buildIncompleteScopedUiTargetsNudge(
+      [{ root: fixture.repo, head: fixture.head, initialDirtyPaths: [] }],
+      'Work on the Example.com listing pages for Alpha.ai, Beta.ai, and Gamma.ai. Make all three pages visually polished.'
+    ),
+    /gamma-ai[\s\S]*blank or too little page source/i,
+    'blank scoped page files should not count as meaningfully addressed targets'
+  );
   writeFileSync(
     path.join(fixture.repo, untrackedGammaRel),
-    '<!doctype html><html><body><main><section><h1>Gamma</h1><p>New scoped page.</p></section></main></body></html>'
+    '<!doctype html><html><body><main><section><h1>Gamma</h1><p>New scoped page with enough visible product copy to prove the target was actually rebuilt rather than created as an empty placeholder file.</p></section></main></body></html>'
   );
   assert.equal(
     worker._buildIncompleteScopedUiTargetsNudge(
@@ -536,7 +545,7 @@ try {
   worker._findIncompleteScopedUiTargets = originalFindIncompleteScopedUiTargets;
   assert.match(
     incompleteRepairLead,
-    /missing-target pass for target page\(s\) not yet changed in the current diff: beta-ai/i,
+    /missing-target pass for target page\(s\) not yet changed with meaningful page content in the current diff: beta-ai/i,
     'missing-target retries should name only the targets not yet addressed'
   );
   assert.match(

package/src/OpenClawCLI.js CHANGED Viewed

@@ -917,7 +917,7 @@ export class OpenClawCLI extends EventEmitter {
   _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,
+      /missing-target pass for target page\(s\) not yet changed(?: with meaningful page content)? in the current diff:\s*([^\n.]+)/i,
       /visual repair pass for currently failing target page\(s\):\s*([^\n.]+)/i,
     ];
     for (const pattern of patterns) {
@@ -1820,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 {
@@ -1830,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 CHANGED Viewed

@@ -775,6 +775,24 @@ export class AgentForgeWorker extends EventEmitter {
     return [...names].sort();
   }
+  _pageSourceContentIssue(repo, rel) {
+    if (!repo || !/\.html?$/i.test(String(rel || ''))) return null;
+    const fullPath = path.join(repo, rel);
+    if (!existsSync(fullPath)) return 'missing page source file';
+    let content = '';
+    try {
+      content = readFileSync(fullPath, 'utf-8');
+    } catch {
+      return 'unreadable page source file';
+    }
+    const trimmed = content.trim();
+    if (trimmed.length < 200) return 'blank or too little page source';
+    if (!/<(?:html|body|main|section|article|h1)\b/i.test(trimmed)) {
+      return 'does not look like a rendered page source';
+    }
+    return null;
+  }
   _isNewScopedPageOwnedAsset(baseline, rel, allowedSlugs, pageOnly) {
     if (!baseline?.root || !pageOnly || !Array.isArray(allowedSlugs) || allowedSlugs.length === 0) return false;
     if (!this._isPageAssetPath(rel)) return false;
@@ -1696,20 +1714,40 @@ export class AgentForgeWorker extends EventEmitter {
       if (changedFiles.length === 0) continue;
       const touchedSlugs = new Set();
+      const touchedFilesBySlug = new Map();
       for (const filePath of changedFiles) {
         const lower = String(filePath || '').toLowerCase();
         for (const slug of allowedSlugs) {
-          if (this._scopeSlugsMatchingText(lower, [slug]).length > 0) touchedSlugs.add(slug);
+          if (this._scopeSlugsMatchingText(lower, [slug]).length > 0) {
+            touchedSlugs.add(slug);
+            if (!touchedFilesBySlug.has(slug)) touchedFilesBySlug.set(slug, []);
+            touchedFilesBySlug.get(slug).push(filePath);
+          }
         }
       }
       const missingSlugs = allowedSlugs.filter(slug => !touchedSlugs.has(slug));
-      if (missingSlugs.length === 0) continue;
+      const contentIssues = [];
+      for (const slug of allowedSlugs.filter(slug => touchedSlugs.has(slug))) {
+        const pageFiles = (touchedFilesBySlug.get(slug) || [])
+          .filter(rel => /\.html?$/i.test(rel));
+        if (pageFiles.length === 0) continue;
+        const issues = pageFiles
+          .map(rel => ({ rel, issue: this._pageSourceContentIssue(baseline.root, rel) }))
+          .filter(item => item.issue);
+        if (issues.length > 0 && issues.length === pageFiles.length) {
+          missingSlugs.push(slug);
+          contentIssues.push(`${slug}: ${issues.map(item => `${item.rel} (${item.issue})`).join(', ')}`);
+        }
+      }
+      const uniqueMissingSlugs = [...new Set(missingSlugs)];
+      if (uniqueMissingSlugs.length === 0) continue;
       warnings.push({
         repo: baseline.root,
-        missingSlugs,
+        missingSlugs: uniqueMissingSlugs,
         touchedSlugs: [...touchedSlugs],
         changedFiles: [...new Set(changedFiles)].slice(0, 8),
+        contentIssues,
       });
     }
@@ -1718,12 +1756,12 @@ export class AgentForgeWorker extends EventEmitter {
   _formatIncompleteScopedUiTargetsNudge(warnings) {
     const lines = warnings.slice(0, 5).map(w =>
-      `- ${w.repo}: missing target(s) ${w.missingSlugs.join(', ')}; changed ${w.changedFiles.join(', ') || 'no UI files'}`
+      `- ${w.repo}: missing or incomplete target(s) ${w.missingSlugs.join(', ')}; changed ${w.changedFiles.join(', ') || 'no UI files'}${w.contentIssues?.length ? `; content issue(s): ${w.contentIssues.join('; ')}` : ''}`
     );
     return [
-      'The task names multiple scoped UI targets, but the current diff does not touch every named target.',
+      'The task names multiple scoped UI targets, but the current diff does not meaningfully address every named target.',
       ...lines,
-      'For scoped page/listing work, each requested target page must be addressed directly unless the final response clearly reports a blocker for that specific target. Continue from the current files and update the missing target page(s), then visually verify all edited target screens.',
+      'For scoped page/listing work, each requested target page must be addressed directly with non-empty, rendered page content unless the final response clearly reports a blocker for that specific target. Continue from the current files and update the missing or incomplete target page(s), then visually verify all edited target screens.',
     ].join('\n');
   }
@@ -1741,7 +1779,7 @@ export class AgentForgeWorker extends EventEmitter {
     const alreadyTouchedSlugs = allSlugs.filter(slug => !missingSlugs.includes(slug));
     return [
       `Original scoped UI target set: ${allSlugs.join(', ')}.`,
-      `This retry is a missing-target pass for target page(s) not yet changed in the current diff: ${missingSlugs.join(', ')}.`,
+      `This retry is a missing-target pass for target page(s) not yet changed with meaningful page content in the current diff: ${missingSlugs.join(', ')}.`,
       alreadyTouchedSlugs.length > 0
         ? `Do not delete, rewrite, or restart target page(s) already changed in this diff just to repeat earlier work: ${alreadyTouchedSlugs.join(', ')}.`
         : '',
@@ -3890,7 +3928,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 +4216,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 +5115,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,