@hamp10/agentforge 0.2.24 → 0.2.26

package/package.json

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

package/scripts/check-task-semantics.js

@@ -648,8 +648,8 @@ try {
   ));
   assert.match(
     cli._detectScreenshotVisualDiscontinuities(seamPng).join('\n'),
-    /hard-edged/i,
-    'screenshot discontinuity scan should catch large hard-edged rectangular seams'
+    /screenshot continuity break/i,
+    'screenshot discontinuity scan should catch large rectangular visual discontinuities'
   );
   const subtlePartialSurfacePng = path.join(fixture.repo, 'subtle-partial-surface.png');
   writeRgbPng(subtlePartialSurfacePng, 1000, 700, (x, y) => {
@@ -658,8 +658,8 @@ try {
   });
   assert.match(
     cli._detectScreenshotVisualDiscontinuities(subtlePartialSurfacePng).join('\n'),
-    /partial-surface hard-edged background\/tint block edge/i,
-    'screenshot discontinuity scan should catch large subtle partial-surface tint blocks'
+    /partial-surface screenshot continuity break/i,
+    'screenshot discontinuity scan should catch large subtle partial-surface visual discontinuities'
   );
 } finally {
   rmSync(fixture.repo, { recursive: true, force: true });
@@ -668,6 +668,7 @@ try {
 const openClawSource = readFileSync(new URL('../src/OpenClawCLI.js', import.meta.url), 'utf-8');
 const workerSource = readFileSync(new URL('../src/worker.js', import.meta.url), 'utf-8');
 const workerBinSource = readFileSync(new URL('../bin/agentforge.js', import.meta.url), 'utf-8');
+const selfUpdateSource = readFileSync(new URL('../src/selfUpdate.js', import.meta.url), 'utf-8');
 const defaultGuidesSource = readFileSync(new URL('../src/default-task-guides.js', import.meta.url), 'utf-8');
 const browserSource = readFileSync(new URL('../src/browser.js', import.meta.url), 'utf-8');
 const previewServerSource = readFileSync(new URL('../src/preview-server.js', import.meta.url), 'utf-8');
@@ -690,13 +691,13 @@ assert.match(
 );
 assert.match(
   openClawSource,
-  /large hard-edged rectangular background\/overlay boundary across a dominant UI surface/i,
-  'screenshot discontinuity detection should fail large hard-edged visual breaks'
+  /visible screenshot continuity break across a dominant UI surface/i,
+  'screenshot discontinuity detection should fail large visual continuity breaks'
 );
 assert.match(
   openClawSource,
-  /partial-surface hard-edged background\/tint block edge/i,
-  'screenshot discontinuity detection should fail subtle partial-surface tint blocks'
+  /partial-surface screenshot continuity break/i,
+  'screenshot discontinuity detection should fail subtle partial-surface visual continuity breaks'
 );
 assert.match(
   openClawSource,
@@ -838,16 +839,41 @@ assert.match(
   /app\.delete\('\/api\/agents\/delete\/cleanup-empty'[\s\S]*activeTasks[\s\S]*type: 'agents_pruned'/i,
   'empty-agent cleanup should preserve live tasks and broadcast removed agents'
 );
+assert.match(
+  serverSource,
+  /CREATE TABLE IF NOT EXISTS agent_flows[\s\S]*config JSONB DEFAULT NULL/i,
+  'agent flow emergency schema patch should include config so model routing survives skipped migrations'
+);
+assert.match(
+  serverSource,
+  /ALTER TABLE agent_flows ADD COLUMN IF NOT EXISTS config JSONB DEFAULT NULL/i,
+  'agent flow startup should self-heal missing config column'
+);
+assert.match(
+  serverSource,
+  /ON CONFLICT \(id\)[\s\S]*WHERE agent_flows\.user_id = EXCLUDED\.user_id[\s\S]*RETURNING id/i,
+  'flow upserts should not update another user flow with the same id'
+);
 assert.match(
   dashboardSource,
   /confirmDeleteAgent[\s\S]*await fetch[\s\S]*removeAgentFromLocalState/i,
   'single-agent delete should only remove local UI after the server confirms deletion'
 );
+assert.match(
+  dashboardSource,
+  /confirmPruneAgents[\s\S]*\/api\/agents\/delete\/prune\?keep=15[\s\S]*removeAgentFromLocalState/i,
+  'dashboard should expose old-agent pruning through the safe keep-latest endpoint'
+);
 assert.match(
   dashboardSource,
   /function finalizeLiveFeedBeforeGuide[\s\S]*commitChunkBuffer[\s\S]*hideTypingIndicator/i,
   'live Guide messages should close the current visible agent feed before rendering the user bubble'
 );
+assert.match(
+  selfUpdateSource,
+  /ensureWritableGlobalInstallEnv[\s\S]*canWriteNpmRoot[\s\S]*configureUserOwnedNpmGlobalEnv/i,
+  'self-update should preflight npm global permissions before printing a failed system-prefix install'
+);
 assert.match(
   dashboardSource,
   /async function sendGuideMessage[\s\S]*agent\._guideInflight[\s\S]*finalizeLiveFeedBeforeGuide\(agentId\)[\s\S]*addMessage/i,
@@ -953,11 +979,31 @@ assert.doesNotMatch(
   /taskRequiresVisualVerification\s*&&\s*directIteration\s*<=\s*1\s*&&\s*explicitScopeForTask\.pageOnly/s,
   'comparable UI context gate should apply on retries, not only first iteration'
 );
+assert.match(
+  openClawSource,
+  /read-only project context, not as a target page/,
+  'read-only comparable page inspection should not be narrated as target-page work'
+);
+assert.match(
+  openClawSource,
+  /verifiedLocalUrl = isLocalUiUrl\(resultUrl \|\| url\)/,
+  'scoped auto-verification should count a clean inferred local target URL even when browser output formatting is imperfect'
+);
 assert.match(
   openClawSource,
   /const minRatio = isLargeText \? 3 : 4\.5;/,
   'control/link contrast checks should use text-size-aware WCAG thresholds'
 );
+assert.match(
+  dashboardSource,
+  /typingEl\.dataset\.startedAt\s*=\s*startedAt/,
+  'live guide insertion should preserve the active feed start time for chronological reload ordering'
+);
+assert.match(
+  dashboardSource,
+  /time:\s*startedAt/,
+  'completed live feeds should save with their start time so guide bubbles appear after the feed they interrupted'
+);
 assert.match(
   defaultGuidesSource,
   /anything that reads as rendering damage rather than deliberate design/i,

package/src/OpenClawCLI.js

@@ -3128,7 +3128,7 @@ export class OpenClawCLI extends EventEmitter {
           horizontal.y < height * 0.94;
         if (!awayFromViewportEdge) continue;
         warnings.push([
-          `large hard-edged rectangular background/overlay boundary across a dominant UI surface near x=${vertical.x}, y=${horizontal.y}`,
+          `visible screenshot continuity break across a dominant UI surface near x=${vertical.x}, y=${horizontal.y}`,
           `(vertical span y=${vertical.minY}-${vertical.maxY}, horizontal span x=${horizontal.minX}-${horizontal.maxX})`,
         ].join(' '));
         break;
@@ -3144,7 +3144,7 @@ export class OpenClawCLI extends EventEmitter {
         edge.average >= 38
       );
       if (dominantVertical) {
-        warnings.push(`large hard-edged vertical background/overlay seam across a dominant UI surface near x=${dominantVertical.x} spanning y=${dominantVertical.minY}-${dominantVertical.maxY}`);
+        warnings.push(`visible vertical screenshot continuity break across a dominant UI surface near x=${dominantVertical.x} spanning y=${dominantVertical.minY}-${dominantVertical.maxY}`);
       }
     }
 
@@ -3197,7 +3197,7 @@ export class OpenClawCLI extends EventEmitter {
       }
 
       if (partialHorizontal) {
-        warnings.push(`large partial-surface hard-edged background/tint block edge near y=${partialHorizontal.y}, running from x=${partialHorizontal.start} to x=${partialHorizontal.end}. This often indicates an unintended rectangular overlay, cropped layer, or mismatched background plane.`);
+        warnings.push(`visible partial-surface screenshot continuity break near y=${partialHorizontal.y}, running from x=${partialHorizontal.start} to x=${partialHorizontal.end}`);
       }
     }
 
@@ -3249,7 +3249,7 @@ export class OpenClawCLI extends EventEmitter {
       }
 
       if (partialVertical) {
-        warnings.push(`large partial-surface hard-edged background/tint block edge near x=${partialVertical.x}, running from y=${partialVertical.start} to y=${partialVertical.end}. This often indicates an unintended rectangular overlay, cropped layer, or mismatched background plane.`);
+        warnings.push(`visible partial-surface screenshot continuity break near x=${partialVertical.x}, running from y=${partialVertical.start} to y=${partialVertical.end}`);
       }
     }
     return warnings;
@@ -3850,7 +3850,7 @@ export class OpenClawCLI extends EventEmitter {
         ? `${visualWarningPrefix}: ${summary.brokenImages.length} visible image(s) failed to load: ${summary.brokenImages.map(img => img.alt || img.src || '(unlabeled image)').join(', ')}. ${visualWarningTail}`
         : '';
       const screenshotDiscontinuityWarning = screenshotDiscontinuityWarnings.length > 0
-        ? `${visualWarningPrefix}: screenshot shows ${screenshotDiscontinuityWarnings.slice(0, 2).join('; ')}. Rework the affected layout/background/layering so the changed screen reads as intentional, then verify the page again. ${visualWarningTail}`
+        ? `${visualWarningPrefix}: screenshot pixel scan flagged visible continuity issue(s): ${screenshotDiscontinuityWarnings.slice(0, 2).join('; ')}. Inspect the screenshot and source to identify the actual rendering cause, then rework the affected layout/background/layering so the changed screen reads as intentional. Verify the page again. ${visualWarningTail}`
         : '';
       const reportLowContrastControls = options?.afterMutation && isScopedBrowserTarget && explicitScopeSlugs.length > 0
         ? (summary.lowContrastControls || []).filter(c => !c.chrome)
@@ -4629,8 +4629,10 @@ export class OpenClawCLI extends EventEmitter {
           recordDirectToolSummary('browser', result);
           continue;
         }
-        rememberLocalScopedUrl(browserResultUrl(result));
-        if (isLocalUiVerificationResult(result)) {
+        const resultUrl = browserResultUrl(result);
+        rememberLocalScopedUrl(resultUrl);
+        const verifiedLocalUrl = isLocalUiUrl(resultUrl || url);
+        if (isLocalUiVerificationResult(result) || verifiedLocalUrl) {
           recordCleanLocalVerification(result, [slug]);
           verifiedAny = true;
         }
@@ -4766,6 +4768,13 @@ export class OpenClawCLI extends EventEmitter {
         return `I am checking the live browser${url} to judge the actual product surface before deciding the next change.`;
       }
       if (name === 'read_file' || name === 'read') {
+        const scope = extractExplicitScope(task);
+        const targetText = String(targetPath || base || '').toLowerCase();
+        const looksLikePageSource = /\.(html?|css|s[ac]ss|jsx?|tsx?|vue|svelte|astro|mdx?)$/i.test(targetText);
+        const isNamedTarget = scope.slugs.length > 0 && scopeSlugsMatchingText(targetText, scope.slugs).length > 0;
+        if (base && looksLikePageSource && scope.slugs.length > 0 && !isNamedTarget) {
+          return `I am reading ${base} as read-only project context, not as a target page.`;
+        }
         return base
           ? `I am reading ${base} to work from the current implementation instead of guessing.`
           : `I am reading the current code before making the next change.`;
@@ -5097,6 +5106,10 @@ export class OpenClawCLI extends EventEmitter {
                     lastDirectVisualWarning = visualWarning;
                   } else if (!taskRequiresVisualVerification || isLocalUiVerificationResult(result)) {
                     recordCleanLocalVerification(result);
+                  } else {
+                    const verifiedUrl = resultUrl || args?.url || '';
+                    const verifiedSlugs = isLocalUiUrl(verifiedUrl) ? scopeSlugsInText(verifiedUrl) : [];
+                    if (verifiedSlugs.length > 0) recordCleanLocalVerification(result, verifiedSlugs);
                   }
                 }
               }

package/src/selfUpdate.js

@@ -6,8 +6,8 @@
  * prevent infinite re-exec loops).
  */
 
-import { execSync, spawn } from 'child_process';
-import { mkdirSync } from 'fs';
+import { execFileSync, execSync, spawn } from 'child_process';
+import { mkdirSync, rmSync } from 'fs';
 import { homedir } from 'os';
 import path from 'path';
 
@@ -75,22 +75,58 @@ export async function checkAndUpdate(packageName, currentVersion) {
 
 function installGlobalPackage(pkg, { force = false } = {}) {
   const forceFlag = force ? ' --force' : '';
+  const preflightEnv = ensureWritableGlobalInstallEnv();
   try {
-    execSync(`npm install -g${forceFlag} ${pkg}`, { stdio: 'inherit' });
+    execSync(`npm install -g${forceFlag} ${pkg}`, { stdio: 'inherit', env: preflightEnv });
     return;
   } catch (error) {
     if (!looksLikePermissionFailure(error)) throw error;
   }
 
+  const env = configureUserOwnedNpmGlobalEnv();
+  execSync(`npm install -g${forceFlag} ${pkg}`, { stdio: 'inherit', env });
+}
+
+function npmConfigGet(args) {
+  try {
+    return execFileSync('npm', args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function canWriteNpmRoot(rootDir) {
+  if (!rootDir) return false;
+  const testDir = path.join(rootDir, `.agentforge-write-test-${process.pid}`);
+  try {
+    mkdirSync(testDir, { recursive: true });
+    rmSync(testDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    try { rmSync(testDir, { recursive: true, force: true }); } catch {}
+    return false;
+  }
+}
+
+function ensureWritableGlobalInstallEnv() {
+  const root = npmConfigGet(['root', '-g']);
+  if (canWriteNpmRoot(root)) return process.env;
+  return configureUserOwnedNpmGlobalEnv();
+}
+
+function configureUserOwnedNpmGlobalEnv() {
   const prefix = path.join(homedir(), '.npm-global');
   mkdirSync(path.join(prefix, 'bin'), { recursive: true });
   mkdirSync(path.join(prefix, 'lib', 'node_modules'), { recursive: true });
-  execSync(`npm config set prefix "${prefix}"`, { stdio: 'inherit' });
+  execFileSync('npm', ['config', 'set', 'prefix', prefix], { stdio: ['ignore', 'ignore', 'inherit'] });
   const env = {
     ...process.env,
     PATH: `${path.join(prefix, 'bin')}${path.delimiter}${process.env.PATH || ''}`,
   };
-  execSync(`npm install -g${forceFlag} ${pkg}`, { stdio: 'inherit', env });
+  return env;
 }
 
 function looksLikePermissionFailure(error) {