@loops-adk/core 0.2.0 → 0.3.0

package/dist/{chunk-WM5QVHM2.js → chunk-3PMVII43.js}

@@ -4,9 +4,9 @@ import { isLimitError, waitMsFor } from './chunk-Y2SD7GBL.js';
 import { LoopError } from './chunk-I3STY7U6.js';
 import { readFileSync, mkdtempSync, existsSync, writeFileSync, appendFileSync, readdirSync, mkdirSync, rmSync } from 'fs';
 import { execa } from 'execa';
+import { createHash, randomBytes } from 'crypto';
 import { tmpdir, homedir } from 'os';
 import { join, dirname } from 'path';
-import { randomBytes } from 'crypto';
 
 // src/core/describe.ts
 var META = /* @__PURE__ */ new WeakMap();
@@ -54,7 +54,11 @@ function renderPlan(meta, indent = "") {
   const out = [];
   switch (meta.kind) {
     case "loop": {
-      const max = typeof meta.max === "number" ? ` (max ${meta.max})` : "";
+      const caps = [];
+      if (typeof meta.max === "number") caps.push(`max ${meta.max}`);
+      if (typeof meta.noProgress === "number")
+        caps.push(`stall after ${meta.noProgress} flat`);
+      const max = caps.length ? ` (${caps.join("; ")})` : "";
       out.push(`${indent}loop${nm}${max}`);
       const start = meta.start;
       const gate = meta.gate;
@@ -812,6 +816,32 @@ async function isDirty(opts) {
   const r = await git(["status", "--porcelain"], opts);
   return r.stdout.trim().length > 0;
 }
+async function workspaceFingerprint(opts) {
+  try {
+    if (!await isRepo(opts)) return void 0;
+    const hash = createHash("sha256");
+    const feed = (label, value) => {
+      hash.update(label);
+      hash.update("");
+      hash.update(value);
+      hash.update("");
+    };
+    feed("head", await headSha(opts) ?? "");
+    feed("status", (await git(["status", "--porcelain"], opts)).stdout);
+    feed("unstaged", (await git(["diff"], opts)).stdout);
+    feed("staged", (await git(["diff", "--cached"], opts)).stdout);
+    const untracked = (await git(["ls-files", "--others", "--exclude-standard"], opts)).stdout.split("\n").filter(Boolean);
+    for (let i = 0; i < untracked.length; i += 500) {
+      const chunk = untracked.slice(i, i + 500);
+      feed(`untracked-paths:${i}`, chunk.join("\n"));
+      const r = await git(["hash-object", "--", ...chunk], opts);
+      if (r.exitCode === 0) feed(`untracked-content:${i}`, r.stdout);
+    }
+    return hash.digest("hex");
+  } catch {
+    return void 0;
+  }
+}
 async function commit(input, opts) {
   if (!input.allowEmpty && !await hasStagedChanges(opts)) return void 0;
   const message = input.body ? `${input.subject}
@@ -1780,6 +1810,102 @@ function fnJob(label, fn) {
   return setMeta(job, { kind: "fn", name: label });
 }
 
+// src/core/progress.ts
+function resolveNoProgress(input) {
+  if (input == null) return void 0;
+  const cfg = typeof input === "number" ? { window: input } : input;
+  return {
+    ...cfg,
+    window: cfg.window ?? 3,
+    minConfidenceDelta: cfg.minConfidenceDelta ?? 0.02
+  };
+}
+var ProgressTracker = class {
+  window;
+  minConfidenceDelta;
+  /** Every state this run has reached, namespaced by channel. */
+  seen = /* @__PURE__ */ new Set();
+  /** Confidence high-water mark — the best score at the last progress point. */
+  best;
+  /** The current run of consecutive no-progress iterations. */
+  stalledRun = [];
+  lastEvidence = [];
+  lastReason = "gate not met";
+  indeterminate = 0;
+  sampled = 0;
+  constructor(cfg) {
+    this.window = cfg.window;
+    this.minConfidenceDelta = cfg.minConfidenceDelta;
+  }
+  /**
+   * Record one iteration. Returns a `StallReport` when this sample fills the
+   * window, else undefined.
+   */
+  record(sample) {
+    this.sampled += 1;
+    if (sample.reason) this.lastReason = sample.reason;
+    const flat = [];
+    let progressed = false;
+    let channels = 0;
+    if (sample.fingerprint !== void 0) {
+      channels += 1;
+      const key = `fp:${sample.fingerprint}`;
+      if (this.seen.has(key)) {
+        flat.push("workspace: no state this run has not already visited");
+      } else {
+        this.seen.add(key);
+        progressed = true;
+      }
+    }
+    if (sample.signal !== void 0) {
+      channels += 1;
+      const key = `sig:${sample.signal}`;
+      if (this.seen.has(key)) {
+        flat.push(`signal: "${sample.signal}" already seen this run`);
+      } else {
+        this.seen.add(key);
+        progressed = true;
+      }
+    }
+    if (sample.confidence !== void 0) {
+      channels += 1;
+      if (this.best === void 0 || sample.confidence >= this.best + this.minConfidenceDelta) {
+        this.best = Math.max(this.best ?? -Infinity, sample.confidence);
+        progressed = true;
+      } else {
+        flat.push(
+          `confidence ${sample.confidence.toFixed(2)} did not improve on ${this.best.toFixed(2)} (needs +${this.minConfidenceDelta})`
+        );
+      }
+    }
+    if (channels === 0) {
+      this.indeterminate += 1;
+      return void 0;
+    }
+    if (progressed) {
+      this.stalledRun = [];
+      return void 0;
+    }
+    this.stalledRun.push(sample.iteration);
+    this.lastEvidence = flat;
+    if (this.stalledRun.length < this.window) return void 0;
+    return {
+      window: this.window,
+      iterations: [...this.stalledRun],
+      reason: this.lastReason,
+      evidence: [...this.lastEvidence]
+    };
+  }
+  /**
+   * True when the detector has seen a full window of samples and none carried
+   * any evidence channel — detection is configured but cannot fire. The loop
+   * uses this to warn once instead of failing silently-inert.
+   */
+  isInert() {
+    return this.indeterminate >= this.window && this.indeterminate === this.sampled;
+  }
+};
+
 // src/core/context.ts
 function childContext(parent, over) {
   return {
@@ -1842,6 +1968,7 @@ function loop(config) {
   const until = config.until ? toCondition(config.until) : void 0;
   const stopOn = config.stopOn ? toCondition(config.stopOn) : void 0;
   const onError = config.retry?.onError ?? "continue";
+  const noProgress = resolveNoProgress(config.noProgress);
   const job = async (parent) => {
     const path = [...parent.path, config.name];
     const depth = parent.depth + 1;
@@ -1928,6 +2055,8 @@ function loop(config) {
       let last;
       let consecutiveErrors = 0;
       let consecutiveReviewFails = 0;
+      const tracker = noProgress ? new ProgressTracker(noProgress) : void 0;
+      let warnedInert = false;
       while (true) {
         await yieldToLoop();
         if (parent.signal.aborted)
@@ -1948,6 +2077,7 @@ function loop(config) {
         }
         iteration += 1;
         const ctx = ctxAt(iteration, last);
+        let turnReview;
         parent.emit({ kind: "loop:iteration", ts: ts(), path, iteration });
         let bodyThrew = false;
         try {
@@ -2133,6 +2263,7 @@ function loop(config) {
           }
           consecutiveReviewFails += 1;
           lastReview = reviewOutcome;
+          turnReview = reviewOutcome;
           parent.log(
             `review did not pass (${reviewOutcome.summary ?? reviewOutcome.status}); re-entering ${config.name}`,
             "warn"
@@ -2148,6 +2279,62 @@ function loop(config) {
             );
           }
         }
+        if (tracker) {
+          let fingerprint;
+          if (noProgress.workspace !== false) {
+            fingerprint = await workspaceFingerprint({
+              cwd: ctx.workspace.dir,
+              signal: parent.signal
+            });
+          }
+          let signalValue;
+          if (noProgress.signal) {
+            try {
+              const v = await noProgress.signal(ctx, last);
+              signalValue = v == null ? void 0 : String(v);
+            } catch (e) {
+              throw LoopError.from(e, {
+                code: "VALIDATION",
+                phase: "body",
+                path,
+                iteration
+              });
+            }
+          }
+          const report = tracker.record({
+            iteration,
+            fingerprint,
+            signal: signalValue,
+            confidence: turnReview?.confidence ?? conv.confidence ?? last.confidence,
+            reason: turnReview ? turnReview.summary ?? "review rejected" : conv.reason
+          });
+          if (!warnedInert && tracker.isInert()) {
+            warnedInert = true;
+            parent.log(
+              `noProgress is set on ${config.name} but no evidence channel exists (no git workspace, no gate confidence, no custom signal); stall detection is inert`,
+              "warn"
+            );
+          }
+          if (report) {
+            parent.emit({
+              kind: "loop:stall",
+              ts: ts(),
+              path,
+              iteration,
+              report
+            });
+            return finish(
+              {
+                status: "exhausted",
+                summary: `stalled after ${report.iterations.length} iterations with no observable progress: ${report.reason}`,
+                confidence: last.confidence,
+                data: last.data,
+                stall: report
+              },
+              iteration
+            );
+          }
+        }
         if (config.delayMs) await delay(config.delayMs, parent.signal);
       }
     } catch (e) {
@@ -2169,6 +2356,7 @@ function loop(config) {
     kind: "loop",
     name: config.name,
     max: config.max,
+    noProgress: noProgress?.window,
     start: describeConditions(config.start),
     gate: describeConditions(config.until),
     stopOn: describeConditions(config.stopOn),
@@ -2685,6 +2873,8 @@ function formatEvent(event) {
       return `${at}  tool ${event.name} ${event.phase}`;
     case "engine:usage":
       return `${at}  ${event.model}: ${event.usage.inputTokens}/${event.usage.outputTokens} tok`;
+    case "loop:stall":
+      return `${at}\u23F9 stalled after ${event.report.iterations.length} no-progress iterations: ${event.report.reason}`;
     case "limit:wait":
       return `${at}\u23F8 limit ${event.code}: waiting ${Math.round(event.waitMs / 1e3)}s`;
     case "limit:pause":
@@ -2901,6 +3091,6 @@ function exitCodeFor(outcome) {
   }
 }
 
-export { Budget, EXIT_PAUSED, EngineRegistry, GhForge, MockForge, Stats, addWorktree, agentCheck, agentContract, agentJob, all, always, any, appendLedger, appendPrompt, bodyPassed, buildChecksArgs, buildCreateArgs, buildEditArgs, buildMergeArgs, buildViewArgs, childContext, commandSucceeds, commit, commitJob, compactLedger, composeCommitBody, conflictedFiles, consolidate, consolidateJob, currentBranch, defineAgent, defineSkill, deleteBranch, describeConditions, ensureIgnored, exitCodeFor, feedbackBlock, fnJob, forgeChecks, formatEvent, fromFile, gateJob, graphPositionBlock, groundingText, hasStagedChanges, headSha, isDirty, isForge, isRepo, isRequiredFeedbackSeverity, jobMeta, kickback, ledgerPath, listRuns, log, loop, mergeAbort, mergeBranch, mergeNoCommit, minConfidence, never, normalizeFeedbackSeverity, not, predicate, promptPath, push, quorum, readLedger, readPrompt, readRunStatus, removeWorktree, renderPlan, resetLedger, resetPrompt, resolveSystem, retrieveLedger, reviewContext, reviewPanel, revisionFromOutcome, revisionRequest, run, runEventsPath, runSemanticRecordsPath, runsHome, semanticRecordsFromEvent, setMeta, stageAll, toCondition };
-//# sourceMappingURL=chunk-WM5QVHM2.js.map
-//# sourceMappingURL=chunk-WM5QVHM2.js.map
+export { Budget, EXIT_PAUSED, EngineRegistry, GhForge, MockForge, ProgressTracker, Stats, addWorktree, agentCheck, agentContract, agentJob, all, always, any, appendLedger, appendPrompt, bodyPassed, buildChecksArgs, buildCreateArgs, buildEditArgs, buildMergeArgs, buildViewArgs, childContext, commandSucceeds, commit, commitJob, compactLedger, composeCommitBody, conflictedFiles, consolidate, consolidateJob, currentBranch, defineAgent, defineSkill, deleteBranch, describeConditions, ensureIgnored, exitCodeFor, feedbackBlock, fnJob, forgeChecks, formatEvent, fromFile, gateJob, graphPositionBlock, groundingText, hasStagedChanges, headSha, isDirty, isForge, isRepo, isRequiredFeedbackSeverity, jobMeta, kickback, ledgerPath, listRuns, log, loop, mergeAbort, mergeBranch, mergeNoCommit, minConfidence, never, normalizeFeedbackSeverity, not, predicate, promptPath, push, quorum, readLedger, readPrompt, readRunStatus, removeWorktree, renderPlan, resetLedger, resetPrompt, resolveNoProgress, resolveSystem, retrieveLedger, reviewContext, reviewPanel, revisionFromOutcome, revisionRequest, run, runEventsPath, runSemanticRecordsPath, runsHome, semanticRecordsFromEvent, setMeta, stageAll, toCondition, workspaceFingerprint };
+//# sourceMappingURL=chunk-3PMVII43.js.map
+//# sourceMappingURL=chunk-3PMVII43.js.map