pulseed 0.0.1 → 0.1.1

package/dist/core/suggest/repo-context.js

@@ -0,0 +1,154 @@
+import * as path from "node:path";
+export function resolveSuggestRepoPath(inputPath = ".") {
+    const displayPath = inputPath.trim().length > 0 ? inputPath : ".";
+    return {
+        resolvedPath: path.resolve(displayPath),
+        displayPath,
+    };
+}
+function normalizeRepoFilePath(targetPath, filePath) {
+    const trimmed = filePath.trim();
+    if (trimmed.length === 0) {
+        return "";
+    }
+    let normalized = trimmed;
+    if (path.isAbsolute(trimmed)) {
+        normalized = path.relative(targetPath, trimmed);
+    }
+    else {
+        const prefixedTarget = targetPath.endsWith(path.sep) ? targetPath : `${targetPath}${path.sep}`;
+        if (trimmed.startsWith(prefixedTarget)) {
+            normalized = path.relative(targetPath, trimmed);
+        }
+    }
+    const withForwardSlashes = normalized.split(path.sep).join("/");
+    return withForwardSlashes === "" ? path.basename(targetPath) : withForwardSlashes;
+}
+export async function listSuggestRepoFiles(targetPath) {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const execFileAsync = promisify(execFile);
+    try {
+        let stdout = "";
+        try {
+            ({ stdout } = await execFileAsync("rg", [
+                "--files",
+                targetPath,
+                "-g", "*.ts",
+                "-g", "*.js",
+                "-g", "*.tsx",
+                "-g", "*.jsx",
+                "-g", "*.json",
+                "-g", "*.md",
+                "-g", "!node_modules/**",
+                "-g", "!dist/**",
+                "-g", "!.git/**",
+            ], { timeout: 5000 }));
+        }
+        catch {
+            ({ stdout } = await execFileAsync("find", [
+                targetPath, "-type", "f",
+                "(",
+                "-name", "*.ts",
+                "-o", "-name", "*.js",
+                "-o", "-name", "*.tsx",
+                "-o", "-name", "*.jsx",
+                "-o", "-name", "*.json",
+                "-o", "-name", "*.md",
+                ")",
+                "-not", "-path", "*/node_modules/*",
+                "-not", "-path", "*/dist/*",
+                "-not", "-path", "*/.git/*",
+            ], { timeout: 5000 }));
+        }
+        return stdout
+            .trim()
+            .split("\n")
+            .map((file) => normalizeRepoFilePath(targetPath, file))
+            .filter(Boolean)
+            .slice(0, 200);
+    }
+    catch {
+        return [];
+    }
+}
+export async function buildSuggestRepoContext(targetPath, repoFiles) {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    const { readFile } = await import("node:fs/promises");
+    const execFileAsync = promisify(execFile);
+    const parts = [];
+    const projectFiles = repoFiles ?? await listSuggestRepoFiles(targetPath);
+    if (projectFiles.length > 0) {
+        parts.push(`Project files:\n${projectFiles.join("\n")}`);
+    }
+    try {
+        const pkg = await readFile(path.join(targetPath, "package.json"), "utf-8");
+        parts.push(`package.json:\n${pkg}`);
+    }
+    catch {
+        // Best-effort context assembly only.
+    }
+    try {
+        let stdout = "";
+        try {
+            ({ stdout } = await execFileAsync("rg", [
+                "-n",
+                "TODO|FIXME",
+                targetPath,
+                "-g", "*.ts",
+                "-g", "*.js",
+                "-g", "!node_modules/**",
+                "-g", "!dist/**",
+                "-g", "!.git/**",
+            ], { timeout: 5000 }));
+        }
+        catch {
+            ({ stdout } = await execFileAsync("grep", [
+                "-rc", "TODO\\|FIXME", targetPath,
+                "--include=*.ts", "--include=*.js",
+            ], { timeout: 5000 }));
+        }
+        const totalCount = stdout.trim().length === 0
+            ? 0
+            : stdout.trim().split("\n").reduce((sum, line) => {
+                if (line.includes(":")) {
+                    const tail = line.split(":").pop() || "0";
+                    const parsed = parseInt(tail, 10);
+                    return sum + (Number.isNaN(parsed) ? 1 : parsed);
+                }
+                return sum + 1;
+            }, 0);
+        parts.push(`TODO/FIXME count: ${totalCount}`);
+    }
+    catch (err) {
+        if (typeof err === "object" && err !== null && "code" in err && err.code === 1) {
+            parts.push("TODO/FIXME count: 0");
+        }
+    }
+    try {
+        let stdout = "";
+        try {
+            ({ stdout } = await execFileAsync("rg", [
+                "--files",
+                targetPath,
+                "-g", "*.test.ts",
+                "-g", "!node_modules/**",
+                "-g", "!dist/**",
+                "-g", "!.git/**",
+            ], { timeout: 5000 }));
+        }
+        catch {
+            ({ stdout } = await execFileAsync("find", [
+                targetPath, "-name", "*.test.ts", "-not", "-path", "*/node_modules/*",
+            ], { timeout: 5000 }));
+        }
+        const testFiles = stdout.trim().split("\n").filter(Boolean);
+        parts.push(`Test files: ${testFiles.length}`);
+    }
+    catch {
+        // Best-effort context assembly only.
+    }
+    return parts.join("\n\n");
+}
+//# sourceMappingURL=repo-context.js.map

package/dist/core/suggest/repo-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-context.js","sourceRoot":"","sources":["../../../src/core/suggest/repo-context.ts"],"names":[],"mappings":"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"}

package/dist/core-loop.d.ts

@@ -0,0 +1,61 @@
+import type { StateDiffCalculator } from "./loop/state-diff.js";
+import type { LoopConfig, LoopIterationResult, LoopResult, CoreLoopDeps } from "./loop/core-loop-types.js";
+export type { GapCalculatorModule, DriveScorerModule, ExecutionSummaryParams, ReportingEngine, LoopConfig, ResolvedLoopConfig, LoopIterationResult, LoopResult, CoreLoopDeps, ProgressEvent, ProgressPhase, } from "./loop/core-loop-types.js";
+export { buildDriveContext, makeEmptyIterationResult } from "./loop/core-loop-types.js";
+/**
+ * CoreLoop is the heart of PulSeed — it orchestrates one full iteration of the
+ * task discovery loop: observe → gap → score → completion check → stall check → task → report.
+ *
+ * It runs multiple iterations until the goal is complete (SatisficingJudge),
+ * max iterations reached, stall escalation occurs, or an external stop signal.
+ */
+export declare class CoreLoop {
+    private readonly deps;
+    /** Mutable config — may be updated mid-run (e.g. treeMode enabled after decomposition). */
+    private config;
+    private readonly logger?;
+    private stopped;
+    private readonly learning;
+    /** Optional StateDiffCalculator for loop-skip optimization. */
+    private readonly stateDiff?;
+    private stateDiffState;
+    /** Tracks goals that have already been through auto-decompose this run. */
+    private decomposedGoals;
+    constructor(deps: CoreLoopDeps, config?: LoopConfig, stateDiff?: StateDiffCalculator);
+    /**
+     * Run the full loop until completion or stop condition.
+     */
+    run(goalId: string): Promise<LoopResult>;
+    /**
+     * Run a single iteration of the loop.
+     */
+    runOneIteration(goalId: string, loopIndex: number): Promise<LoopIterationResult>;
+    /**
+     * Tree-mode iteration: select one node via TreeLoopOrchestrator, run a
+     * normal observe→gap→score→task cycle on that node, then aggregate upward.
+     *
+     * Called by run() when treeMode=true.
+     */
+    runTreeIteration(rootId: string, loopIndex: number, nodeConsumedMap: Map<string, number>): Promise<LoopIterationResult>;
+    /**
+     * Run one iteration of the multi-goal loop.
+     *
+     * Uses CrossGoalPortfolio (if available) to determine goal allocations,
+     * then calls portfolioManager.selectNextStrategyAcrossGoals() to pick
+     * which goal gets the next iteration. Falls back to equal allocation if
+     * CrossGoalPortfolio is not injected.
+     *
+     * Requires config.multiGoalMode=true and config.goalIds to be set.
+     * Throws if CrossGoalPortfolio is not injected and multiGoalMode is enabled.
+     */
+    runMultiGoalIteration(loopIndex: number): Promise<LoopIterationResult>;
+    /**
+     * Stop the loop externally (e.g., on SIGTERM).
+     */
+    stop(): void;
+    /**
+     * Check if the loop has been stopped.
+     */
+    isStopped(): boolean;
+}
+//# sourceMappingURL=core-loop.d.ts.map

package/dist/core-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-loop.d.ts","sourceRoot":"","sources":["../src/core-loop.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAqB,MAAM,sBAAsB,CAAC;AAQnF,OAAO,KAAK,EACV,UAAU,EAEV,mBAAmB,EACnB,UAAU,EACV,YAAY,EAEb,MAAM,2BAA2B,CAAC;AAwBnC,YAAY,EACV,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,UAAU,EACV,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAmBxF;;;;;;GAMG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAe;IACpC,2FAA2F;IAC3F,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4C;IACrE,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAsB;IACjD,OAAO,CAAC,cAAc,CAA+F;IACrH,2EAA2E;IAC3E,OAAO,CAAC,eAAe,CAAqB;gBAEhC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,mBAAmB;IAcpF;;OAEG;IACG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAiN9C;;OAEG;IACG,eAAe,CACnB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,mBAAmB,CAAC;IA0K/B;;;;;OAKG;IACG,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAK7H;;;;;;;;;;OAUG;IACG,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAK5E;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,SAAS,IAAI,OAAO;CAIrB"}

package/dist/core-loop.js

@@ -0,0 +1,410 @@
+import { sleep } from "./utils/sleep.js";
+import { IterationBudget } from "./loop/iteration-budget.js";
+import { saveLoopCheckpoint, restoreLoopCheckpoint } from "./loop/checkpoint-manager-loop.js";
+import { runPostLoopHooks } from "./loop/post-loop-hooks.js";
+import { tryRunParallel } from "./loop/parallel-dispatch.js";
+import { generateLoopReport } from "./loop/loop-report-helper.js";
+import { makeEmptyIterationResult } from "./loop/core-loop-types.js";
+import { runTreeIteration as runTreeIterationImpl, runMultiGoalIteration as runMultiGoalIterationImpl, } from "./loop/tree-loop-runner.js";
+import { loadGoalWithAggregation, observeAndReload, calculateGapOrComplete, scoreDrivesAndCheckKnowledge, phaseAutoDecompose, } from "./loop/core-loop-phases.js";
+import { checkCompletionAndMilestones, detectStallsAndRebalance, checkDependencyBlock, runTaskCycleWithContext, } from "./loop/core-loop-phases-b.js";
+import { handleCapabilityAcquisition } from "./loop/core-loop-capability.js";
+import { CoreLoopLearning } from "./loop/core-loop-learning.js";
+export { buildDriveContext, makeEmptyIterationResult } from "./loop/core-loop-types.js";
+const DEFAULT_CONFIG = {
+    maxIterations: 100,
+    maxConsecutiveErrors: 3,
+    delayBetweenLoopsMs: 1000,
+    adapterType: "openai_codex_cli",
+    treeMode: false,
+    multiGoalMode: false,
+    goalIds: [],
+    minIterations: 1,
+    autoArchive: false,
+    dryRun: false,
+    maxConsecutiveSkips: 5,
+    autoDecompose: true,
+};
+// ─── CoreLoop ───
+/**
+ * CoreLoop is the heart of PulSeed — it orchestrates one full iteration of the
+ * task discovery loop: observe → gap → score → completion check → stall check → task → report.
+ *
+ * It runs multiple iterations until the goal is complete (SatisficingJudge),
+ * max iterations reached, stall escalation occurs, or an external stop signal.
+ */
+export class CoreLoop {
+    deps;
+    /** Mutable config — may be updated mid-run (e.g. treeMode enabled after decomposition). */
+    config;
+    logger;
+    stopped = false;
+    learning = new CoreLoopLearning();
+    /** Optional StateDiffCalculator for loop-skip optimization. */
+    stateDiff;
+    stateDiffState = new Map();
+    /** Tracks goals that have already been through auto-decompose this run. */
+    decomposedGoals = new Set();
+    constructor(deps, config, stateDiff) {
+        this.deps = deps;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.logger = deps.logger;
+        this.stateDiff = stateDiff;
+        // Wire optional StrategyTemplateRegistry into StrategyManager for auto-templating
+        if (deps.strategyTemplateRegistry) {
+            deps.strategyManager.setStrategyTemplateRegistry(deps.strategyTemplateRegistry);
+        }
+    }
+    // ─── Public API ───
+    /**
+     * Run the full loop until completion or stop condition.
+     */
+    async run(goalId) {
+        const startedAt = new Date().toISOString();
+        this.stopped = false;
+        // Reset state diff tracking for each run (snapshots are in-memory only)
+        this.stateDiffState.clear();
+        // Reset auto-decompose tracking for each run
+        this.decomposedGoals.clear();
+        // Load and validate goal
+        const goal = await this.deps.stateManager.loadGoal(goalId);
+        if (!goal) {
+            return {
+                goalId,
+                totalIterations: 0,
+                finalStatus: "error",
+                iterations: [],
+                startedAt,
+                completedAt: new Date().toISOString(),
+            };
+        }
+        if (goal.status !== "active" && goal.status !== "waiting") {
+            const msg = `Goal "${goalId}" cannot be run: status is "${goal.status}" (expected "active" or "waiting")`;
+            this.logger?.error(msg);
+            return {
+                goalId,
+                totalIterations: 0,
+                finalStatus: "error",
+                errorMessage: msg,
+                iterations: [],
+                startedAt,
+                completedAt: new Date().toISOString(),
+            };
+        }
+        // Reset stall escalation state at the beginning of each run so prior
+        // run's escalation does not immediately poison a fresh start.
+        // Gap history is intentionally preserved across runs (appended) for historical tracking.
+        for (const dim of goal.dimensions) {
+            await this.deps.stallDetector.resetEscalation(goalId, dim.name);
+        }
+        // Restore dimension/trust state from checkpoint if present (§4.8).
+        // cycle_number is used to resume iteration counting so loopIndex values are
+        // cumulative across runs. --max-iterations limits total NEW iterations per run.
+        // NOTE: this checkpoint (goals/<goalId>/checkpoint.json) is for crash-recovery state
+        // (dimension values, trust balance) — it is distinct from CheckpointManager in
+        // src/execution/checkpoint-manager.ts, which handles multi-agent session transfer.
+        const startLoopIndex = await restoreLoopCheckpoint(this.deps.stateManager, goalId, this.config.adapterType, this.deps.trustManager);
+        const iterations = [];
+        let consecutiveErrors = 0;
+        let consecutiveDenied = 0;
+        let consecutiveEscalations = 0;
+        let finalStatus = "max_iterations";
+        // Use the provided iterationBudget if set; otherwise create a local one from maxIterations.
+        // A provided budget is shared (e.g. with parent/child agents); a local budget is loop-private.
+        const budget = this.config.iterationBudget
+            ?? new IterationBudget(this.config.maxIterations);
+        // Per-node iteration tracking for tree mode — persists across loop iterations so
+        // per-node limits accumulate correctly (not reset each call).
+        const nodeConsumedMap = new Map();
+        for (let loopIndex = startLoopIndex; loopIndex < startLoopIndex + this.config.maxIterations; loopIndex++) {
+            if (this.stopped) {
+                finalStatus = "stopped";
+                break;
+            }
+            // Check shared iteration budget before each iteration (but do not consume yet)
+            if (budget.exhausted) {
+                this.logger?.info("Iteration budget exhausted, stopping loop");
+                break;
+            }
+            const iterationResult = this.config.treeMode && this.deps.treeLoopOrchestrator
+                ? await this.runTreeIteration(goalId, loopIndex, nodeConsumedMap)
+                : await this.runOneIteration(goalId, loopIndex);
+            // Carry forward gapAggregate from the previous iteration when this one was skipped,
+            // so callers always see a meaningful value rather than the default 0.
+            if (iterationResult.skipped && iterations.length >= 1) {
+                iterationResult.gapAggregate = iterations[iterations.length - 1].gapAggregate;
+            }
+            // Only consume budget for non-skipped iterations — skipped iterations do minimal
+            // work (observation only) and should not count against the shared budget.
+            if (!iterationResult.skipped) {
+                const { allowed, warnings } = budget.consume();
+                for (const w of warnings) {
+                    this.logger?.warn(w);
+                }
+                if (!allowed) {
+                    this.logger?.info("Iteration budget exhausted, stopping loop");
+                    break;
+                }
+            }
+            iterations.push(iterationResult);
+            // Save checkpoint after each successful verify step (§4.8)
+            if (!this.config.dryRun && iterationResult.error === null && iterationResult.taskResult !== null) {
+                await saveLoopCheckpoint(this.deps.stateManager, goalId, loopIndex, iterationResult, this.config.adapterType, this.deps.trustManager, this.logger);
+            }
+            // Check completion (R1-2: must complete at least minIterations before exiting)
+            if (iterationResult.completionJudgment.is_complete &&
+                loopIndex >= (this.config.minIterations ?? 1) - 1) {
+                finalStatus = "completed";
+                break;
+            }
+            // Check errors
+            if (iterationResult.error !== null) {
+                consecutiveErrors++;
+                if (consecutiveErrors >= this.config.maxConsecutiveErrors) {
+                    finalStatus = "error";
+                    break;
+                }
+            }
+            else {
+                consecutiveErrors = 0;
+            }
+            // Check approval_denied and escalate counters
+            const taskAction = iterationResult.taskResult?.action ?? null;
+            if (taskAction === "approval_denied") {
+                consecutiveDenied++;
+                if (consecutiveDenied >= 3) {
+                    finalStatus = "stopped";
+                    break;
+                }
+            }
+            else {
+                consecutiveDenied = 0;
+            }
+            if (taskAction === "escalate") {
+                consecutiveEscalations++;
+                if (consecutiveEscalations >= 3) {
+                    finalStatus = "stalled";
+                    break;
+                }
+            }
+            else {
+                consecutiveEscalations = 0;
+            }
+            // Check stall escalation (escalation_level >= 3 means max escalation)
+            if (iterationResult.stallDetected &&
+                iterationResult.stallReport &&
+                iterationResult.stallReport.escalation_level >= 3) {
+                finalStatus = "stalled";
+                break;
+            }
+            // Check stopped again after iteration
+            if (this.stopped) {
+                finalStatus = "stopped";
+                break;
+            }
+            // Periodic learning review
+            await this.learning.checkPeriodicReview(goalId, this.deps, this.logger);
+            // Delay between loops (skip on last iteration)
+            if (loopIndex < startLoopIndex + this.config.maxIterations - 1 && this.config.delayBetweenLoopsMs > 0) {
+                await sleep(this.config.delayBetweenLoopsMs);
+            }
+        }
+        // Run post-loop hooks (curiosity, memory lifecycle, archive, final report)
+        await runPostLoopHooks({
+            goalId,
+            finalStatus,
+            iterations,
+            deps: this.deps,
+            config: this.config,
+            logger: this.logger,
+            tryGenerateReport: (id, idx, r, g) => generateLoopReport(id, idx, r, g, this.deps.reportingEngine, this.logger),
+        });
+        // After loop completes, trigger learning pipeline for goal completion
+        // (kept here so CoreLoopLearning state stays inside CoreLoop)
+        if (finalStatus === "completed") {
+            await this.learning.onGoalCompleted(goalId, this.deps, this.logger);
+        }
+        return {
+            goalId,
+            totalIterations: iterations.length,
+            finalStatus,
+            iterations,
+            startedAt,
+            completedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Run a single iteration of the loop.
+     */
+    async runOneIteration(goalId, loopIndex) {
+        const startTime = Date.now();
+        const ctx = { deps: this.deps, config: this.config, logger: this.logger };
+        // Default result (filled in progressively)
+        const result = makeEmptyIterationResult(goalId, loopIndex);
+        // 1. Load goal + tree aggregation
+        const loadedGoal = await loadGoalWithAggregation(ctx, goalId, result, startTime);
+        if (!loadedGoal)
+            return result;
+        let goal = loadedGoal;
+        await phaseAutoDecompose(goalId, goal, this.deps, this.config, this.logger, this.decomposedGoals);
+        // After decomposition: if children were created, reload and switch to tree mode
+        // so subsequent iterations use runTreeIteration instead of runOneIteration.
+        if (!goal.children_ids.length) {
+            const reloadedAfterDecompose = await this.deps.stateManager.loadGoal(goalId);
+            if (reloadedAfterDecompose && reloadedAfterDecompose.children_ids.length > 0) {
+                goal = reloadedAfterDecompose;
+                if (this.deps.treeLoopOrchestrator) {
+                    this.config = { ...this.config, treeMode: true };
+                    this.logger?.info("[CoreLoop] treeMode enabled after auto-decomposition", { goalId, childrenCount: goal.children_ids.length });
+                }
+            }
+        }
+        // 2. Observe + reload
+        goal = await observeAndReload(ctx, goalId, goal, loopIndex);
+        // 2b. State diff check (Pillar 2: State Diff + Loop Skip)
+        // When StateDiffCalculator is present and no meaningful change is detected,
+        // skip phases 3-9 to avoid redundant LLM calls. After maxConsecutiveSkips,
+        // the full loop runs so stall detection can fire.
+        if (this.stateDiff) {
+            const diffState = this.stateDiffState.get(goalId) ?? { previousSnapshot: null, consecutiveSkips: 0 };
+            const snapshot = this.stateDiff.buildSnapshot(goal, loopIndex);
+            const diff = this.stateDiff.compare(diffState.previousSnapshot, snapshot);
+            diffState.previousSnapshot = snapshot;
+            if (!diff.hasChange && diffState.consecutiveSkips < this.config.maxConsecutiveSkips) {
+                diffState.consecutiveSkips++;
+                this.stateDiffState.set(goalId, diffState);
+                this.logger?.info(`[CoreLoop] iteration ${loopIndex} skipped: no state change detected ` +
+                    `(consecutiveSkips=${diffState.consecutiveSkips}/${this.config.maxConsecutiveSkips})`, { goalId });
+                result.skipped = true;
+                result.skipReason = "no_state_change";
+                this.deps.onProgress?.({
+                    iteration: loopIndex + 1,
+                    maxIterations: this.config.maxIterations,
+                    phase: "Skipped",
+                    skipReason: result.skipReason,
+                });
+                // Carry forward completion status from the already-loaded goal so a
+                // completed goal is not forced through 5 more iterations.
+                // Reload fresh state to ensure we reflect any status changes since observation.
+                const goalState = await this.deps.stateManager.loadGoal(goalId);
+                if (goalState?.status === "completed") {
+                    result.completionJudgment.is_complete = true;
+                }
+                this.deps.onProgress?.({
+                    iteration: loopIndex + 1,
+                    maxIterations: this.config.maxIterations,
+                    phase: "Skipped (no state change)",
+                });
+                result.elapsedMs = Date.now() - startTime;
+                return result;
+            }
+            // Reset skip counter — full loop is running
+            diffState.consecutiveSkips = 0;
+            this.stateDiffState.set(goalId, diffState);
+            if (!diff.hasChange) {
+                this.logger?.info(`[CoreLoop] max consecutive skips reached (${this.config.maxConsecutiveSkips}), ` +
+                    "forcing full iteration for stall detection", { goalId });
+            }
+        }
+        // 3. Gap calculate + zero check
+        const gapResult = await calculateGapOrComplete(ctx, goalId, goal, loopIndex, result, startTime);
+        if (!gapResult) {
+            // null means a hard error occurred — result.error is already set
+            return result;
+        }
+        const { gapVector, gapAggregate, skipTaskGeneration } = gapResult;
+        // 4. Drive scoring + knowledge gap check (skip when gap=0 — no task needed)
+        let driveScores = [];
+        let highDissatisfactionDimensions = [];
+        if (!skipTaskGeneration) {
+            const driveResult = await scoreDrivesAndCheckKnowledge(ctx, goalId, goal, gapVector, loopIndex, result, startTime, (id, idx, r, g) => generateLoopReport(id, idx, r, g, this.deps.reportingEngine, this.logger));
+            if (!driveResult)
+                return result;
+            driveScores = driveResult.driveScores;
+            highDissatisfactionDimensions = driveResult.highDissatisfactionDimensions;
+        }
+        // 5. Completion check + milestones
+        await checkCompletionAndMilestones(ctx, goalId, goal, result, startTime);
+        if (result.error)
+            return result;
+        // 6. Stall detection + rebalance
+        // Run even when gap=0 (skipTaskGeneration=true): if gap=0 persists but
+        // is_complete=false (e.g. waiting for double-confirmation), stall detection
+        // must still fire so the loop can escalate rather than spin indefinitely.
+        await detectStallsAndRebalance(ctx, goalId, goal, result);
+        // When gap=0, SatisficingJudge in Phase 5 is the authority on completion.
+        // If it says not complete (e.g. low confidence), continue the loop normally
+        // but skip task generation since there is no gap to close.
+        if (skipTaskGeneration) {
+            await generateLoopReport(goalId, loopIndex, result, goal, this.deps.reportingEngine, this.logger);
+            result.elapsedMs = Date.now() - startTime;
+            return result;
+        }
+        // 6b. Dependency block check
+        if (checkDependencyBlock(ctx, goalId, result))
+            return result;
+        // 6c. TaskGroup detection and routing (M15 Phase 2)
+        // When parallelExecutor and generateTaskGroupFn are both provided, attempt
+        // to decompose large tasks into a TaskGroup and execute in parallel waves.
+        if (this.deps.parallelExecutor && this.deps.generateTaskGroupFn) {
+            const parallelResult = await tryRunParallel(goalId, goal, gapAggregate, result, startTime, this.deps, this.logger);
+            if (parallelResult !== null) {
+                // Parallel path completed — skip normal task cycle
+                await generateLoopReport(goalId, loopIndex, result, goal, this.deps.reportingEngine, this.logger);
+                result.elapsedMs = Date.now() - startTime;
+                return result;
+            }
+            // parallelResult === null means TaskGroup decomposition was skipped or failed;
+            // fall through to normal single-task cycle below.
+        }
+        // 7. Task cycle with context
+        const loopCallbacks = {
+            handleCapabilityAcquisition: (task, gId, adapter) => handleCapabilityAcquisition(task, gId, adapter, this.deps.capabilityDetector, this.learning.getCapabilityFailures(), this.logger),
+            incrementTransferCounter: () => this.learning.incrementTransferCounter(),
+            tryGenerateReport: (id, idx, r, g) => generateLoopReport(id, idx, r, g, this.deps.reportingEngine, this.logger),
+        };
+        const taskCycleOk = await runTaskCycleWithContext(ctx, goalId, goal, gapVector, driveScores, highDissatisfactionDimensions, loopIndex, result, startTime, loopCallbacks);
+        if (!taskCycleOk)
+            return result;
+        // 8. Report
+        await generateLoopReport(goalId, loopIndex, result, goal, this.deps.reportingEngine, this.logger);
+        result.elapsedMs = Date.now() - startTime;
+        return result;
+    }
+    /**
+     * Tree-mode iteration: select one node via TreeLoopOrchestrator, run a
+     * normal observe→gap→score→task cycle on that node, then aggregate upward.
+     *
+     * Called by run() when treeMode=true.
+     */
+    async runTreeIteration(rootId, loopIndex, nodeConsumedMap) {
+        return runTreeIterationImpl(rootId, loopIndex, this.deps, this.config, this.logger, (id, idx) => this.runOneIteration(id, idx), nodeConsumedMap);
+    }
+    /**
+     * Run one iteration of the multi-goal loop.
+     *
+     * Uses CrossGoalPortfolio (if available) to determine goal allocations,
+     * then calls portfolioManager.selectNextStrategyAcrossGoals() to pick
+     * which goal gets the next iteration. Falls back to equal allocation if
+     * CrossGoalPortfolio is not injected.
+     *
+     * Requires config.multiGoalMode=true and config.goalIds to be set.
+     * Throws if CrossGoalPortfolio is not injected and multiGoalMode is enabled.
+     */
+    async runMultiGoalIteration(loopIndex) {
+        return runMultiGoalIterationImpl(loopIndex, this.deps, this.config, (id, idx) => this.runOneIteration(id, idx));
+    }
+    /**
+     * Stop the loop externally (e.g., on SIGTERM).
+     */
+    stop() {
+        this.stopped = true;
+    }
+    /**
+     * Check if the loop has been stopped.
+     */
+    isStopped() {
+        return this.stopped;
+    }
+}
+//# sourceMappingURL=core-loop.js.map