create-walle 0.9.26 → 0.9.27

package/template/wall-e/lib/scheduler.js

@@ -29,6 +29,30 @@ const DEFAULT_MAX_MISSED_JOBS_PER_RESTART = 5;
 const DEFAULT_SLOW_TICK_MS = 250;
 const DEFAULT_SLOW_JOB_MS = 2_000;
 const PERF_LOG_THROTTLE_MS = 30_000;
+const DEFAULT_NON_BLOCKING_CATCHUP_MAX_WORK_MS = 5_000;
+const DEFAULT_NON_BLOCKING_CATCHUP_DELAY_MS = 2 * 60 * 1000;
+const DEFAULT_RESTART_DEFER_JOB_NAMES = [
+  'harvest',
+  'training',
+  'replay',
+  'agent-benchmark',
+  'weekly-eval-loop',
+  'brain-optimize',
+  'dedup',
+  'daily-backup',
+  'brain-retention',
+  'question-digest',
+];
+
+function _normalizeLane(value, priority = 5) {
+  const n = Number(value);
+  if (Number.isFinite(n)) return Math.max(0, Math.trunc(n));
+  const p = Number(priority);
+  if (!Number.isFinite(p)) return 2;
+  if (p <= 2) return 0;
+  if (p <= 5) return 1;
+  return 2;
+}
 
 /** Default cascade check: true if any numeric value in result is > 0 */
 function _defaultCascadeCheck(result) {
@@ -130,6 +154,7 @@ class Scheduler extends EventEmitter {
    * @param {number}   desc.intervalMs
    * @param {string}   [desc.pool]       - Resource pool name
    * @param {number}   [desc.priority=5] - 1 (highest) to 10 (lowest)
+   * @param {number}   [desc.lane]       - 0 foreground, 1 normal, 2 background
    * @param {string[]} [desc.dependsOn]  - Jobs that must complete once before this runs
    * @param {string[]} [desc.cascadeFrom] - Jobs whose results trigger immediate eligibility
    * @param {number}   [desc.startDelayMs=0]
@@ -155,6 +180,7 @@ class Scheduler extends EventEmitter {
       worker: this._workerJobNames.has(desc.name),
       ...desc,
     };
+    desc.lane = _normalizeLane(desc.lane, desc.priority);
     if (desc.worker && !desc.timeoutMs && this._defaultWorkerJobTimeoutMs > 0) {
       desc.timeoutMs = this._defaultWorkerJobTimeoutMs;
     }
@@ -298,7 +324,7 @@ class Scheduler extends EventEmitter {
   getJobs() {
     return Object.entries(this.getState())
       .map(([name, state]) => ({ name, ...state }))
-      .sort((a, b) => a.priority - b.priority || a.name.localeCompare(b.name));
+      .sort((a, b) => a.lane - b.lane || a.priority - b.priority || a.name.localeCompare(b.name));
   }
 
   /**
@@ -374,6 +400,7 @@ class Scheduler extends EventEmitter {
     return {
       enabled: desc.enabled,
       pool: desc.pool || null,
+      lane: desc.lane,
       priority: desc.priority,
       intervalMs: desc.intervalMs,
       timeoutMs: desc.timeoutMs || null,
@@ -681,8 +708,12 @@ class Scheduler extends EventEmitter {
     }
     summary.candidates = candidates.length;
 
-    // 3. Sort by priority (lower = higher priority)
-    candidates.sort((a, b) => a.descriptor.priority - b.descriptor.priority);
+    // 3. Sort by lane first (foreground before background), then priority.
+    candidates.sort((a, b) =>
+      a.descriptor.lane - b.descriptor.lane
+      || a.descriptor.priority - b.descriptor.priority
+      || a.descriptor.name.localeCompare(b.descriptor.name)
+    );
 
     // 4. Dispatch respecting pool limits. Worker-thread requests register
     // asynchronously inside WorkerThreadSlot.request(), so reserve the slots we
@@ -802,6 +833,38 @@ class Scheduler extends EventEmitter {
     }
   }
 
+  _completeSchedulerCatchupWorkItem(job, result) {
+    const id = job && job._runtimeCatchupWorkItemId;
+    if (!id || !this._persistBrain || typeof this._persistBrain.completeRuntimeWorkItem !== 'function') return;
+    try {
+      this._persistBrain.completeRuntimeWorkItem(id, {
+        cursor: {
+          completedBy: 'scheduler',
+          runCount: result && typeof result === 'object' ? result.count : undefined,
+        },
+      });
+      job._runtimeCatchupWorkItemId = null;
+    } catch (e) {
+      const name = job?.descriptor?.name || id;
+      console.warn(`[scheduler] Could not complete catch-up work item for "${name}": ${e.message}`);
+    }
+  }
+
+  _failSchedulerCatchupWorkItem(job, err) {
+    const id = job && job._runtimeCatchupWorkItemId;
+    if (!id || !this._persistBrain || typeof this._persistBrain.failRuntimeWorkItem !== 'function') return;
+    try {
+      this._persistBrain.failRuntimeWorkItem(id, {
+        error: err,
+        retryAfterMs: this._minRefireGapMs,
+      });
+      job._runtimeCatchupWorkItemId = null;
+    } catch (e) {
+      const name = job?.descriptor?.name || id;
+      console.warn(`[scheduler] Could not update failed catch-up work item for "${name}": ${e.message}`);
+    }
+  }
+
   _dispatch(job) {
     const { name, pool, run, onResult, onError } = job.descriptor;
     job.state.status = 'running';
@@ -857,6 +920,7 @@ class Scheduler extends EventEmitter {
         job.state.lastError = null;
         job.state.runCount++;
         job.state.completedOnce = true;
+        this._completeSchedulerCatchupWorkItem(job, result);
 
         // Recovery: clear consecutive-error tracking + dismiss any active
         // scheduler:job_failure:<name> alert. Failure-alert behavior is
@@ -889,6 +953,7 @@ class Scheduler extends EventEmitter {
         failure = err;
         job.state.lastError = err.message;
         job.state.errorCount++;
+        this._failSchedulerCatchupWorkItem(job, err);
 
         // Failure-alert hook: bumps consecutiveErrors, emits service alert
         // when threshold (default 2) hit and outside cooldown (default 1h).
@@ -950,6 +1015,8 @@ class Scheduler extends EventEmitter {
       const result = await this._workerPool.request('scheduler.runJob', payload, {
         timeoutMs,
         heavy: true,
+        lane: desc.lane,
+        priority: desc.priority,
         terminateOnTimeout: timeoutMs > 0,
       });
       workerMeta.worker_used = true;
@@ -1053,9 +1120,19 @@ class Scheduler extends EventEmitter {
   async runMissedJobs(opts = {}) {
     const max = opts.max ?? this._maxMissedJobsPerRestart;
     const staggerMs = opts.staggerMs ?? this._missedJobStaggerMs;
+    const nonBlocking = opts.nonBlocking === true;
+    const deferNames = new Set(opts.deferNames || DEFAULT_RESTART_DEFER_JOB_NAMES);
+    const deferDelayMs = Number.isFinite(Number(opts.deferDelayMs))
+      ? Math.max(0, Math.trunc(Number(opts.deferDelayMs)))
+      : DEFAULT_NON_BLOCKING_CATCHUP_DELAY_MS;
+    const maxWorkMs = Number.isFinite(Number(opts.maxWorkMs))
+      ? Math.max(0, Math.trunc(Number(opts.maxWorkMs)))
+      : DEFAULT_NON_BLOCKING_CATCHUP_MAX_WORK_MS;
+    const enqueueWorkItem = typeof opts.enqueueWorkItem === 'function' ? opts.enqueueWorkItem : null;
     const op = runtimeHealth.beginOperation('scheduler.runMissedJobs', {
       max,
       staggerMs,
+      nonBlocking,
     });
     if (!this._persistJobState || !this._persistBrain) {
       const summary = { ran: 0, deferred: 0, reason: 'persistence-disabled' };
@@ -1104,8 +1181,55 @@ class Scheduler extends EventEmitter {
     candidates.sort((a, b) =>
       (a.stored.next_eligible_at || 0) - (b.stored.next_eligible_at || 0)
     );
-    const immediate = candidates.slice(0, max);
-    const deferred = candidates.slice(max);
+    let eligibleCandidates = candidates;
+    const policyDeferred = [];
+    if (nonBlocking) {
+      eligibleCandidates = [];
+      for (const candidate of candidates) {
+        const policy = candidate.job.descriptor.restartCatchupPolicy
+          || (deferNames.has(candidate.stored.job_name) ? 'defer' : 'run');
+        if (policy === 'skip' || policy === 'defer') {
+          policyDeferred.push({ ...candidate, reason: policy === 'skip' ? 'restart-skip' : 'restart-defer-policy' });
+        } else {
+          eligibleCandidates.push(candidate);
+        }
+      }
+    }
+
+    const immediate = eligibleCandidates.slice(0, max);
+    const deferred = [
+      ...eligibleCandidates.slice(max).map((candidate) => ({ ...candidate, reason: 'restart-catchup-cap' })),
+      ...policyDeferred,
+    ];
+
+    if (nonBlocking && deferred.length > 0) {
+      const deferredAt = Date.now();
+      deferred.forEach((candidate, index) => {
+        const { job } = candidate;
+        job.state.nextEligibleAt = deferredAt + deferDelayMs + (index * Math.min(5000, this._minRefireGapMs));
+        this._persistState(job.descriptor.name, job);
+        if (enqueueWorkItem) {
+          const workItemId = `scheduler-catchup:${job.descriptor.name}`;
+          try {
+            enqueueWorkItem({
+              id: workItemId,
+              kind: 'scheduler.catchup',
+              lane: job.descriptor.lane,
+              priority: job.descriptor.priority,
+              payload: {
+                jobName: job.descriptor.name,
+                reason: candidate.reason,
+                trigger: 'restart-catchup',
+              },
+              not_before: job.state.nextEligibleAt,
+            });
+            job._runtimeCatchupWorkItemId = workItemId;
+          } catch (e) {
+            console.warn(`[scheduler] Could not enqueue catch-up work item for "${job.descriptor.name}": ${e.message}`);
+          }
+        }
+      });
+    }
 
     if (deferred.length > 0) {
       console.log(
@@ -1130,8 +1254,14 @@ class Scheduler extends EventEmitter {
     let ran = 0;
     let workMs = 0;
     let staggerWaitMs = 0;
+    let budgetDeferred = [];
+    const jobsRan = [];
     for (let i = 0; i < immediate.length; i++) {
       const { job } = immediate[i];
+      if (nonBlocking && workMs >= maxWorkMs && ran > 0) {
+        budgetDeferred = immediate.slice(i).map((candidate) => ({ ...candidate, reason: 'restart-catchup-budget' }));
+        break;
+      }
       // Mark eligible RIGHT NOW so _dispatch picks it up
       job.state.nextEligibleAt = Date.now();
       job._wakeTrigger = 'restart-catchup';
@@ -1141,9 +1271,10 @@ class Scheduler extends EventEmitter {
       try {
         const workStartedAt = Date.now();
         this._dispatch(job);
-        if (job.runPromise) await job.runPromise;
+        if (!nonBlocking && job.runPromise) await job.runPromise;
         workMs += Date.now() - workStartedAt;
         ran++;
+        jobsRan.push(job.descriptor.name);
       } catch (e) {
         console.warn(`[scheduler] Missed-job replay for "${job.descriptor.name}" threw: ${e.message}`);
       }
@@ -1154,14 +1285,25 @@ class Scheduler extends EventEmitter {
       }
     }
 
+    if (nonBlocking && budgetDeferred.length > 0) {
+      const deferredAt = Date.now();
+      budgetDeferred.forEach((candidate, index) => {
+        const { job } = candidate;
+        job.state.nextEligibleAt = deferredAt + deferDelayMs + (index * Math.min(5000, this._minRefireGapMs));
+        this._persistState(job.descriptor.name, job);
+      });
+    }
+
     const summary = {
       ran,
-      deferred: deferred.length + skipped.length,
-      jobs_ran: immediate.map((c) => c.stored.job_name),
+      deferred: deferred.length + skipped.length + budgetDeferred.length,
+      jobs_ran: jobsRan,
       jobs_deferred: [
         ...deferred.map((c) => c.stored.job_name),
+        ...budgetDeferred.map((c) => c.stored.job_name),
         ...skipped.map((c) => c.job.descriptor.name),
       ],
+      non_blocking: nonBlocking,
       jobs_skipped: skipped.map((c) => ({ name: c.job.descriptor.name, reason: c.reason })),
       work_ms: workMs,
       stagger_wait_ms: staggerWaitMs,
@@ -1186,4 +1328,8 @@ module.exports = {
   MIN_REFIRE_GAP_MS,
   DEFAULT_MISSED_JOB_STAGGER_MS,
   DEFAULT_MAX_MISSED_JOBS_PER_RESTART,
+  DEFAULT_NON_BLOCKING_CATCHUP_MAX_WORK_MS,
+  DEFAULT_NON_BLOCKING_CATCHUP_DELAY_MS,
+  DEFAULT_RESTART_DEFER_JOB_NAMES,
+  _normalizeLane,
 };

package/template/wall-e/lib/worker-thread-pool.js

@@ -59,6 +59,7 @@ class WorkerThreadSlot {
       failed: 0,
       active: null,
       pending: 0,
+      pendingByLane: {},
       timedOut: 0,
       lastTimeoutAt: null,
       lastTimeoutOp: null,
@@ -184,7 +185,14 @@ class WorkerThreadSlot {
       this._pending.set(requestId, { op, resolve, reject, timer });
       this._status.pendingClientRequests = this._pending.size;
       try {
-        this._worker.postMessage({ type: 'request', requestId, op, payload });
+        this._worker.postMessage({
+          type: 'request',
+          requestId,
+          op,
+          payload,
+          lane: options.lane,
+          priority: options.priority,
+        });
       } catch (err) {
         this._finishRequest(requestId, _serializeError(err));
       }

package/template/wall-e/loops/think.js

@@ -8,9 +8,31 @@ const { perfLogsEnabled } = require('../lib/diagnostics-flags');
 let embeddings;
 try { embeddings = require('../embeddings'); } catch { embeddings = null; }
 
-const BATCH_SIZE = 20;
+const DEFAULT_BATCH_SIZE = 20;
+const LOCAL_MODEL_BATCH_SIZE = 5;
 const THINK_PHASE_LOG_THRESHOLD_MS = Math.max(0, Number(process.env.WALLE_THINK_PHASE_LOG_THRESHOLD_MS || 1000));
 
+function resolveThinkBatchSize(opts = {}, env = process.env) {
+  const explicit = Number(opts.batchSize ?? env.WALL_E_THINK_BATCH_SIZE ?? env.WALLE_THINK_BATCH_SIZE);
+  if (Number.isFinite(explicit) && explicit > 0) return Math.max(1, Math.min(100, Math.trunc(explicit)));
+
+  const hint = [
+    opts.model,
+    opts.provider,
+    env.WALL_E_PROVIDER,
+    env.WALLE_PROVIDER,
+    env.WALL_E_MODEL_PROVIDER,
+    env.WALLE_MODEL_PROVIDER,
+    env.WALL_E_MODEL,
+    env.WALLE_MODEL,
+  ].filter(Boolean).join(' ').toLowerCase();
+
+  if (/(^|[\s/@:_-])(ollama|local|llama|gemma|qwen|mistral|phi)(?=$|[\s/@:_-]|\d)/.test(hint)) {
+    return LOCAL_MODEL_BATCH_SIZE;
+  }
+  return DEFAULT_BATCH_SIZE;
+}
+
 function _phaseMeta(meta = {}) {
   const out = {};
   for (const [key, value] of Object.entries(meta || {})) {
@@ -90,7 +112,8 @@ async function runOnce(opts = {}) {
   const extractFn = opts.extractFn || extractKnowledge;
   const ownerName = brain.getOwnerName();
 
-  const pending = brain.listMemories({ extractionStatus: 'pending', limit: BATCH_SIZE });
+  const batchSize = resolveThinkBatchSize(opts);
+  const pending = brain.listMemories({ extractionStatus: 'pending', limit: batchSize });
   if (pending.length === 0) {
     // Still run self-resolution even with no new memories
     await selfResolveQuestions(ownerName, opts);
@@ -281,4 +304,4 @@ async function selfResolveQuestions(ownerName, opts = {}) {
   }
 }
 
-module.exports = { runOnce, _shouldAskAboutContradiction };
+module.exports = { runOnce, resolveThinkBatchSize, _shouldAskAboutContradiction };

package/template/wall-e/mcp-server.js

@@ -22,6 +22,25 @@ const DEFAULT_MCP_LOOKUP_CONTEXT_PACK_TIMEOUT_MS = 1200;
 const DEFAULT_MCP_LOOKUP_EMBEDDING_TIMEOUT_MS = 700;
 const MAX_MCP_LOOKUP_TIMEOUT_MS = 10_000;
 
+function _envFlag(name) {
+  const raw = process.env[name];
+  if (raw == null || raw === '') return null;
+  if (/^(1|true|yes|on)$/i.test(String(raw).trim())) return true;
+  if (/^(0|false|no|off)$/i.test(String(raw).trim())) return false;
+  return null;
+}
+
+function canOffloadMcpLookupToWorker() {
+  const explicit = _envFlag('WALL_E_MCP_LOOKUP_WORKER');
+  if (explicit != null) return explicit;
+  const role = process.env.WALL_E_PROCESS_ROLE || '';
+  if (role === 'wall-e-runtime-worker') return false;
+  // Runtime workers open the configured persistent brain DB. Embedded MCP imports
+  // such as tests, CTM, or stdio repair mode may have already initialized brain.js
+  // against a custom DB path, so keep those lookups in-process.
+  return role === 'walle-daemon';
+}
+
 const MCP_RESOURCES = [
   {
     uri: 'walle://status/session-memory',
@@ -722,10 +741,7 @@ async function executeTool(name, args) {
       return routeWallEQuery(args.query, { context: args.context });
     }
     case 'walle_lookup_context': {
-      const canOffload =
-        process.env.WALL_E_PROCESS_ROLE !== 'wall-e-runtime-worker' &&
-        (process.env.NODE_ENV !== 'test' || process.env.WALL_E_RUNTIME_WORKER_POOL_TEST === '1');
-      if (canOffload) {
+      if (canOffloadMcpLookupToWorker()) {
         try {
           return await require('./lib/runtime-worker-pool').requestRuntimeWorker(
             'mcp.lookupWallEContext',

package/template/wall-e/sources/jsonl-utils.js

@@ -3,27 +3,98 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
+const { StringDecoder } = require('node:string_decoder');
 
 const { applyTransforms } = require('./transforms');
 
-function readJsonlFile(filePath) {
+const DEFAULT_JSONL_READ_CHUNK_BYTES = 256 * 1024;
+const DEFAULT_JSONL_MAX_LINE_CHARS = 4 * 1024 * 1024;
+
+function jsonlMaxLineChars(env = process.env) {
+  const n = Number(env.WALL_E_SOURCE_JSONL_MAX_LINE_CHARS ?? env.WALLE_SOURCE_JSONL_MAX_LINE_CHARS);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_JSONL_MAX_LINE_CHARS;
+  return Math.max(4096, Math.trunc(n));
+}
+
+function jsonlReadChunkBytes(env = process.env) {
+  const n = Number(env.WALL_E_SOURCE_JSONL_READ_CHUNK_BYTES ?? env.WALLE_SOURCE_JSONL_READ_CHUNK_BYTES);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_JSONL_READ_CHUNK_BYTES;
+  return Math.max(4096, Math.min(2 * 1024 * 1024, Math.trunc(n)));
+}
+
+function _processJsonlLine({ line, lineNo, events, diagnostics, filePath, maxLineChars }) {
+  if (!line || !line.trim()) return;
+  if (line.length > maxLineChars) {
+    diagnostics.push({
+      level: 'warn',
+      message: `Skipping oversized JSONL line ${lineNo}: ${line.length} chars exceeds ${maxLineChars}`,
+      filePath,
+      line: lineNo,
+      code: 'jsonl_line_too_large',
+    });
+    return;
+  }
+  try {
+    events.push({ line: lineNo, event: JSON.parse(line) });
+  } catch (err) {
+    diagnostics.push({ level: 'warn', message: `Malformed JSONL line ${lineNo}: ${err.message}`, filePath, line: lineNo });
+  }
+}
+
+function readJsonlFile(filePath, opts = {}) {
   const events = [];
   const diagnostics = [];
-  let raw = '';
+  const maxLineChars = opts.maxLineChars || jsonlMaxLineChars(opts.env || process.env);
+  const chunkBytes = opts.chunkBytes || jsonlReadChunkBytes(opts.env || process.env);
+  let fd = null;
   try {
-    raw = fs.readFileSync(filePath, 'utf8');
+    fd = fs.openSync(filePath, 'r');
   } catch (err) {
     return { events, diagnostics: [{ level: 'error', message: err.message, filePath }] };
   }
-  const lines = raw.split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line.trim()) continue;
-    try {
-      events.push({ line: i + 1, event: JSON.parse(line) });
-    } catch (err) {
-      diagnostics.push({ level: 'warn', message: `Malformed JSONL line ${i + 1}: ${err.message}`, filePath, line: i + 1 });
+
+  const decoder = new StringDecoder('utf8');
+  const buffer = Buffer.allocUnsafe(chunkBytes);
+  let pending = '';
+  let lineNo = 1;
+  let skippingOversize = false;
+  try {
+    while (true) {
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+      if (bytesRead <= 0) break;
+      pending += decoder.write(buffer.subarray(0, bytesRead));
+      let newlineIndex;
+      while ((newlineIndex = pending.indexOf('\n')) !== -1) {
+        const line = pending.slice(0, newlineIndex).replace(/\r$/, '');
+        pending = pending.slice(newlineIndex + 1);
+        if (skippingOversize) {
+          skippingOversize = false;
+          lineNo += 1;
+          continue;
+        }
+        _processJsonlLine({ line, lineNo, events, diagnostics, filePath, maxLineChars });
+        lineNo += 1;
+      }
+      if (pending.length > maxLineChars) {
+        diagnostics.push({
+          level: 'warn',
+          message: `Skipping oversized JSONL line ${lineNo}: exceeds ${maxLineChars} chars while streaming`,
+          filePath,
+          line: lineNo,
+          code: 'jsonl_line_too_large',
+        });
+        pending = '';
+        skippingOversize = true;
+      }
+    }
+    pending += decoder.end();
+    if (!skippingOversize) {
+      _processJsonlLine({ line: pending.replace(/\r$/, ''), lineNo, events, diagnostics, filePath, maxLineChars });
     }
+  } catch (err) {
+    diagnostics.push({ level: 'error', message: err.message, filePath });
+  } finally {
+    try { fs.closeSync(fd); } catch {}
   }
   return { events, diagnostics };
 }
@@ -174,6 +245,8 @@ module.exports = {
   looksLikeToolResult,
   parseToolInput,
   readJsonlFile,
+  jsonlMaxLineChars,
+  jsonlReadChunkBytes,
   sourceIdFromFile,
   summarizeToolInput,
   toIso,

package/template/wall-e/tools/local-tools.js

@@ -1531,6 +1531,18 @@ function hasShellControlArg(args) {
   return args.some((arg) => /^(?:[<>]|<<|>>|\||&&|\|\||;)$/.test(String(arg || '').trim()));
 }
 
+// Cloning a project/site into a working copy is the scatter antipattern (session
+// c3f3af97: `cp -R` the source 34× into site-v2-fixed-* throwaway trees the user
+// never opened, then edited those instead of the real file). `cp` has legitimate
+// uses, so we don't hard-block it — we surface a non-fatal hint steering the agent
+// back to editing the target in place. Matches recursive copies (cp -R/-r/-a,
+// --recursive/--archive) and rsync, not plain single-file copies.
+const PROJECT_CLONE_RE = /\bcp\s+(?:-[a-zA-Z]*[rRa][a-zA-Z]*|--(?:recursive|archive))\b|\brsync\b/;
+const CLONE_ADVISORY = 'Recursive directory copy detected. Do not clone a project/site into a copy or variant directory (e.g. *-fixed, *-v2, *-backup, a timestamped dir) as a place to work — that strands your edits in a throwaway tree the user never opens and forces re-investigation next turn. Edit the target files in place at their real path. If you were told to keep your version in a specific folder, create that ONE folder once and keep editing it; reuse a destination you already made instead of copying the source again.';
+function looksLikeProjectClone(commandStr) {
+  return typeof commandStr === 'string' && PROJECT_CLONE_RE.test(commandStr);
+}
+
 /**
  * Run a shell command with tree-sitter analysis gating.
  *
@@ -1655,6 +1667,9 @@ async function runShell(commandOrOpts, legacyArgs, legacyOpts) {
     if (looksLikeSerialLoop && elapsedMs >= SHELL_PROGRESS_AFTER_MS) {
       result.hint = `This serial loop took ${Math.round(elapsedMs / 1000)}s. For many similar operations, prefer ONE batched command (most CLIs accept multiple paths) or run it with background:true and poll bg_output, instead of a loop of separate run_shell calls.`;
     }
+    if (looksLikeProjectClone(commandStr)) {
+      result.hint = result.hint ? `${result.hint} ${CLONE_ADVISORY}` : CLONE_ADVISORY;
+    }
     return result;
   } catch (err) {
     // User Stop / turn abort: the child was killed via the AbortSignal. Return a
@@ -5433,6 +5448,7 @@ module.exports = {
   MAIL_AUTOMATION_LOCK_PATH, MAIL_AUTOMATION_COOLDOWN_PATH,
   getSystemInfo, webFetch,
   globFiles, grepFiles, listDirectory, isBinaryFile,
+  looksLikeProjectClone,
   SHELL_ALLOWLIST, SHELL_DENYLIST,
   isProtectedPath, resolveProjectPath,
   _collectGmailAttachments, _decodeBase64UrlToBuffer, _sanitizeAttachmentFilename,

package/template/wall-e/workers/runtime-worker.js

@@ -10,6 +10,20 @@ let completed = 0;
 let failed = 0;
 const queue = [];
 
+function _priorityValue(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, Math.trunc(n)) : fallback;
+}
+
+function _queuedByLane() {
+  const byLane = {};
+  for (const task of queue) {
+    const lane = String(task.lane);
+    byLane[lane] = (byLane[lane] || 0) + 1;
+  }
+  return byLane;
+}
+
 function _serializeError(err) {
   return {
     message: err && err.message ? err.message : String(err || 'unknown error'),
@@ -24,6 +38,7 @@ function _status() {
     active,
     running: !!active,
     pending: queue.length,
+    pendingByLane: _queuedByLane(),
     enqueued,
     completed,
     failed,
@@ -94,7 +109,16 @@ function _enqueue(msg) {
     requestId: msg.requestId,
     op: msg.op,
     payload: msg.payload || {},
+    lane: _priorityValue(msg.lane, 2),
+    priority: _priorityValue(msg.priority, 5),
+    enqueuedAt: Date.now(),
   });
+  queue.sort((a, b) => (
+    a.lane - b.lane
+    || a.priority - b.priority
+    || a.enqueuedAt - b.enqueuedAt
+    || a.requestId - b.requestId
+  ));
   _pump();
 }