@hank-warren/pi-loop 0.5.0 → 0.7.0

package/src/loop.ts

@@ -3,37 +3,29 @@
  * loop-aware compaction, wired to Pi's extension events.
  *
  * Design invariants (approved plan):
- * - The settled idle boundary is the pacemaker for a standalone loop: an
- *   agent_end records a continuation *intent*, and the next fully settled
- *   boundary dispatches it. The interval is a fallback heartbeat, re-armed
- *   from the last settle, that fires only when the session has been idle a
- *   whole interval with the objective unfinished (a lost continuation, or an
- *   external wait). A goal-bound loop is unchanged: pi-goal owns its settle
- *   continuations, and the interval is still that loop's only driver.
+ * - The settled idle boundary is the pacemaker: an agent_end records a
+ *   continuation *intent*, and the next fully settled boundary dispatches it.
+ *   The interval is a fallback heartbeat, re-armed from the last settle, that
+ *   fires only when the session has been idle a whole interval with the
+ *   objective unfinished (a lost continuation, or an external wait).
  * - Timers are armed in session_start, a settle, or a command handler, never
  *   the factory, and cleared in an idempotent session_shutdown.
  * - Pokes deliver only at a fully idle boundary; a tick that lands while the
  *   agent is busy coalesces into a single pending wake delivered at the next
  *   agent_settled. Missed ticks never stack, and a continuation supersedes a
  *   coalesced wake rather than delivering both.
- * - Loops require an active pi-goal goal to operate: pi-goal owns "whether
- *   the work is done". Its safety states pause the loop, its completion stops
- *   it, and a missing goal pauses the loop. Coupling is read-only session
- *   entries.
- * - Terminal decisions (expiry, completion, safety) also land at a settled
- *   boundary, so the loop settles as soon as the goal does; only the timer
- *   ever pokes.
+ * - A loop owns "whether the work is done" itself: it ends through
+ *   `loop_complete`, a cap, its expiry, or the user, and reads no other
+ *   extension's state to decide that.
+ * - Terminal decisions (expiry, caps) also land at a settled boundary, so the
+ *   loop settles as soon as the work does; only the timer ever pokes.
  * - The loop's proactive compaction is the normal compaction path; Pi's
- *   reserve-token auto-compaction is the fault handler. pi-goal owns the
- *   post-compaction re-prompt: the loop sends none of its own.
+ *   reserve-token auto-compaction is the fault handler. The loop owns the
+ *   post-compaction re-anchor.
  */
 
 import { randomUUID } from "node:crypto";
-import type {
-	ExtensionAPI,
-	ExtensionCommandContext,
-	ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { LoopStartArguments } from "./command.js";
 import {
 	type ContinuationDecision,
@@ -45,16 +37,17 @@ import {
 import { formatClock, formatDuration, MAX_INTERVAL_MS, parseDuration } from "./interval.js";
 import {
 	createLedger,
+	criteriaFromDescriptions,
 	deriveCriteria,
 	type LedgerPaths,
 	ledgerPaths,
+	type LoopCriterion,
 	readCriteria,
 } from "./ledger.js";
 import {
 	buildCompactionInstructions,
 	buildContinuation,
 	buildExpiryWake,
-	buildGoalPoke,
 	buildKickoffAnchor,
 	buildObjectivePoke,
 	type ContinuationKind,
@@ -67,10 +60,8 @@ import {
 	readLoopSettings,
 } from "./settings.js";
 import {
-	isStandaloneLoop,
 	LOOP_STATE_ENTRY_TYPE,
 	type LoopState,
-	readGoalSnapshot,
 	readPlanModeEnabled,
 	restoreLoopState,
 } from "./state.js";
@@ -106,6 +97,17 @@ export const MAX_DEAD_DELIVERIES = 3;
 /** Why the loop caused the run that is currently in flight. */
 type RunOrigin = "continuation" | "fallback";
 
+/**
+ * The outcome of a start attempt.
+ *
+ * `startLoop` used to report its refusals by calling `ctx.ui.notify` itself,
+ * which tied the only start path to a UI. Two callers now share that path —
+ * the `/loop` command and the `loop_start` tool — and the tool has to turn
+ * the same refusal into tool content rather than a toast, so the decision is
+ * returned and each caller renders it.
+ */
+export type LoopStartResult = { ok: true; loop: LoopState } | { ok: false; message: string };
+
 interface ContinuationIntent {
 	loopId: string;
 	kind: ContinuationKind;
@@ -189,7 +191,7 @@ export class LoopController {
 				this.transition("stopped", "loop expired while the session was away");
 				return;
 			}
-			if (!isStandaloneLoop(this.state) && this.migrateGoalBoundLoop(ctx)) return;
+			if (this.state.objective === undefined && this.adoptLegacyObjective(ctx)) return;
 			// A restored loop keeps its ledger: createLedger only ever creates
 			// PROGRESS.md, so days of agent-written state survive a restart.
 			this.openLedger(this.state);
@@ -211,11 +213,11 @@ export class LoopController {
 	}
 
 	/**
-	 * A finished agent run with an active standalone loop is the signal that
-	 * paces the loop: record the *intent* to continue here and let the settled
-	 * boundary decide whether it may be delivered. Recording at agent_end (not
-	 * at settle) is what makes the intent survive Pi's own retries and
-	 * auto-compaction, which run between the two events.
+	 * A finished agent run with an active loop is the signal that paces it:
+	 * record the *intent* to continue here and let the settled boundary decide
+	 * whether it may be delivered. Recording at agent_end (not at settle) is
+	 * what makes the intent survive Pi's own retries and auto-compaction, which
+	 * run between the two events.
 	 */
 	/** A run started, so the delivery that caused it was not a dead one. */
 	onAgentStart(ctx: ExtensionContext): void {
@@ -230,7 +232,7 @@ export class LoopController {
 		const origin = this.runOrigin;
 		this.runOrigin = undefined;
 		const loop = this.state;
-		if (!loop || loop.status !== "active" || !isStandaloneLoop(loop)) return;
+		if (!loop || loop.status !== "active") return;
 		if (this.enforceToolAvailability(ctx)) return;
 		// The expiry's final turn is the last one: never queue a continuation
 		// behind it. The settle that follows stops the loop.
@@ -382,69 +384,52 @@ export class LoopController {
 			return;
 		}
 		// Re-arm the heartbeat from this settle, so it can only fire after a full
-		// interval of genuine idleness. A goal-bound loop keeps the old cadence:
-		// its timer is the only driver it has.
-		if (isStandaloneLoop(this.state)) this.armFallback();
+		// interval of genuine idleness.
+		this.armFallback();
 	}
 
 	/**
 	 * A settled boundary with no wake pending still evaluates the terminal
-	 * decisions — expiry, a completed or missing goal, a pi-goal safety state —
-	 * so the loop settles the moment the goal does instead of up to one interval
-	 * later. Poke and skip decisions are deliberately ignored here: only the
-	 * timer pokes, and settling is not a schedule.
+	 * decisions — expiry and the caps — so the loop settles the moment the work
+	 * does instead of up to one interval later. Poke and skip decisions are
+	 * deliberately ignored here: only the timer pokes, and settling is not a
+	 * schedule.
 	 */
 	private settleTerminalState(ctx: ExtensionContext): boolean {
 		const loop = this.state;
 		if (!loop) return false;
 		const env = this.gatherEnvironment(ctx);
 		const decision = decideTick(loop, env);
-		if (decision.action !== "expire" && decision.action !== "stop" && decision.action !== "pause") {
-			return false;
-		}
+		if (decision.action !== "expire" && decision.action !== "stop") return false;
 		this.lastDecision = { ...decision, at: env.now };
 		this.applyTerminalDecision(loop, decision);
 		return true;
 	}
 
 	/**
-	 * Migration for goal-bound loops, which are deprecated.
+	 * The restore shim for a loop persisted before 0.6.0.
 	 *
-	 * A goal-bound loop delegated "is the work done" to pi-goal. Now that a
-	 * standalone loop owns completion itself, that delegation is the deprecated
-	 * path, and this converts one in place at restore rather than leaving the
-	 * user with a loop that pauses forever the moment its goal is gone.
+	 * Such a loop may carry no objective of its own: it delegated "is the work
+	 * done" to a goal in another extension that no longer exists here. The only
+	 * case that can still reach this code is a session persisted before 0.6.0
+	 * and resumed after it, having never been restored under 0.5.0 — where it
+	 * would already have been converted.
 	 *
-	 * The one case it must *not* convert is a still-active goal: pi-goal is
-	 * driving that session's continuations, and a standalone loop driving them
-	 * too would send two messages at every settle. That loop keeps its old
-	 * behaviour and gets the notice instead.
+	 * Its focus text, when it has one, is the closest thing to an objective it
+	 * has, so adopt that. With nothing to adopt there is no honest way to run
+	 * it, so it pauses and says so.
 	 *
-	 * Returns true when the loop was stopped or paused and needs no timer.
+	 * Returns true when the loop was paused and needs no timer.
 	 */
-	private migrateGoalBoundLoop(ctx: ExtensionContext): boolean {
+	private adoptLegacyObjective(ctx: ExtensionContext): boolean {
 		const loop = this.state;
 		if (!loop) return true;
-		const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
-		if (goal?.status === "active") {
-			ctx.ui.notify(
-				"This loop is bound to a /goal, which is deprecated: pi-loop now owns long-running work on its own. It keeps working as before for now — start future loops with /loop <interval> <objective>.",
-				"warning",
-			);
-			return false;
-		}
-		if (goal?.status === "complete") {
-			this.transition("stopped", "the goal completed");
-			return true;
-		}
-		// The goal is gone or held: nothing is driving this loop any more, so
-		// adopt whatever objective text is still readable and carry on.
-		const objective = goal?.text ?? loop.prompt;
+		const objective = loop.prompt;
 		if (!objective) {
 			this.transition(
 				"paused",
-				"it was bound to a goal that is gone, and it has no objective text of its own to adopt; start a new loop with /loop <interval> <objective>",
-				"goal-bound loop with no objective",
+				"it was bound to a goal that is gone and has no objective of its own; start a new loop with /loop <interval> <objective>",
+				"loop with no objective",
 			);
 			return true;
 		}
@@ -452,15 +437,15 @@ export class LoopController {
 		this.state = { ...rest, objective };
 		this.persist();
 		ctx.ui.notify(
-			`Goal-bound loops are deprecated; this one now owns its objective directly: ${objective}`,
+			`This loop predates pi-loop owning its own objective; it now works its focus text directly: ${objective}`,
 			"info",
 		);
 		return false;
 	}
 
 	/**
-	 * A standalone loop that cannot call `loop_complete` cannot end itself: it
-	 * will work, finish, and then be told to keep working until it hits a cap.
+	 * A loop that cannot call `loop_complete` cannot end itself: it will work,
+	 * finish, and then be told to keep working until it hits a cap.
 	 * That happens whenever the tool set is restricted (`--tools`, `--no-tools`,
 	 * a policy that drops extension tools), and it is invisible from inside the
 	 * loop — so check the live tool set and pause instead of spinning.
@@ -469,7 +454,7 @@ export class LoopController {
 	 */
 	private enforceToolAvailability(ctx: ExtensionContext): boolean {
 		const loop = this.state;
-		if (!loop || loop.status !== "active" || !isStandaloneLoop(loop)) return false;
+		if (!loop || loop.status !== "active") return false;
 		if (this.completeToolAvailable()) return false;
 		this.transition(
 			"paused",
@@ -523,7 +508,7 @@ export class LoopController {
 	 */
 	enterWait(reason: string, resumeAfterMs: number | undefined): ResolvedWaitDelay | undefined {
 		const loop = this.state;
-		if (!loop || loop.status !== "active" || !isStandaloneLoop(loop)) return undefined;
+		if (!loop || loop.status !== "active") return undefined;
 		const resolved = resolveWaitDelay(resumeAfterMs);
 		const waiting = createLoopWait(reason, resumeAfterMs, this.now());
 		// The wait replaces any continuation already recorded for this turn.
@@ -584,17 +569,24 @@ export class LoopController {
 	// --- ledger ---
 
 	/**
-	 * Create (or adopt) the ledger for a standalone loop. Best-effort by
-	 * design: a loop with no writable ledger still runs, it just loses the
-	 * durable record, so the failure is warned once and never repeated.
+	 * Create (or adopt) the loop's ledger. Best-effort by design: a loop with
+	 * no writable ledger still runs, it just loses the durable record, so the
+	 * failure is warned once and never repeated.
+	 *
+	 * `criteria` is passed at start: the criteria proposed at `loop_start`, or
+	 * the deterministic split of the objective. On restore it is omitted, and
+	 * the criteria already on disk are authoritative — they are the ones the
+	 * user saw echoed, and re-deriving them would both discard a proposed set
+	 * and reset whatever `passes` flips the loop has earned.
 	 */
-	private openLedger(loop: LoopState): void {
+	private openLedger(loop: LoopState, criteria?: LoopCriterion[]): void {
 		if (loop.objective === undefined) {
 			this.ledger = undefined;
 			return;
 		}
 		const paths = ledgerPaths(loop.id, this.agentDir);
-		const failure = createLedger(paths, loop.objective, deriveCriteria(loop.objective));
+		const contents = criteria ?? readCriteria(paths) ?? deriveCriteria(loop.objective);
+		const failure = createLedger(paths, loop.objective, contents);
 		if (failure) {
 			this.ledger = undefined;
 			if (!this.ledgerWarned) {
@@ -729,7 +721,6 @@ export class LoopController {
 			busy: !ctx.isIdle() || ctx.hasPendingMessages(),
 			compacting: this.compacting,
 			planModeEnabled: readPlanModeEnabled(branch),
-			goal: readGoalSnapshot(branch),
 		};
 	}
 
@@ -757,7 +748,7 @@ export class LoopController {
 				this.updateWidget();
 				return;
 			case "poke":
-				this.deliverPoke(env, decision.reason);
+				this.deliverPoke(env.now, decision.reason);
 				return;
 			default:
 				this.applyTerminalDecision(loop, decision);
@@ -767,7 +758,7 @@ export class LoopController {
 
 	private applyTerminalDecision(
 		loop: LoopState,
-		decision: Extract<TickDecision, { action: "expire" | "stop" | "pause" }>,
+		decision: Extract<TickDecision, { action: "expire" | "stop" }>,
 	): void {
 		switch (decision.action) {
 			case "expire":
@@ -775,22 +766,7 @@ export class LoopController {
 				this.transition("stopped", "loop expired (the expiry was reached)");
 				return;
 			case "stop":
-				this.transition(
-					"stopped",
-					decision.reason === "goal-complete"
-						? "the goal completed"
-						: decision.reason === "max-automatic-turns"
-							? `the ${loop.maxAutomaticTurns}-automatic-turn cap was reached`
-							: `the ${loop.maxIterations}-iteration cap was reached`,
-				);
-				return;
-			case "pause":
-				this.transition(
-					"paused",
-					decision.reason === "goal-missing"
-						? "loops require an active goal; start one with /goal <objective>, then /loop resume"
-						: `pi-goal reports the goal is ${decision.cause}; resolve it, then /loop resume`,
-				);
+				this.transition("stopped", `the ${loop.maxTurns}-turn cap was reached`);
 				return;
 		}
 	}
@@ -837,24 +813,15 @@ export class LoopController {
 
 	/**
 	 * Send first, then account. Pi can refuse the delivery (a busy or compacting
-	 * session), and an iteration persisted before the send would burn the
-	 * maxIterations cap on a poke that never arrived; on a throw the loop re-arms
-	 * on the same cadence and retries at the next wake.
+	 * session), and a turn persisted before the send would burn the cap on a
+	 * poke that never arrived; on a throw the loop re-arms on the same cadence
+	 * and retries at the next wake.
 	 */
-	private deliverPoke(
-		env: TickEnvironment,
-		reason: "goal-stalled" | "goal-waiting" | "objective-stalled" | "wait-elapsed",
-	): void {
+	private deliverPoke(now: number, reason: "objective-stalled" | "wait-elapsed"): void {
 		const loop = this.state;
 		if (!loop) return;
-		const standalone = reason === "objective-stalled" || reason === "wait-elapsed";
-		// A goal-bound poke restates nothing, so it is only meaningful while the
-		// goal it points at is readable; a standalone poke needs no goal at all.
-		if (!standalone && !env.goal) return;
 		try {
-			this.pi.sendUserMessage(
-				standalone ? buildObjectivePoke(loop, reason) : buildGoalPoke(loop, reason),
-			);
+			this.pi.sendUserMessage(buildObjectivePoke(loop, reason));
 		} catch (error) {
 			this.sessionCtx?.ui.notify(
 				`pi-loop could not deliver a wake: ${formatError(error)}. Retrying at the next interval.`,
@@ -872,7 +839,7 @@ export class LoopController {
 			...this.consumeWait(loop),
 			iteration: loop.iteration + 1,
 			automaticTurns: loop.automaticTurns + 1,
-			lastWakeAt: env.now,
+			lastWakeAt: now,
 		};
 		this.persist();
 		this.armFallback();
@@ -894,15 +861,11 @@ export class LoopController {
 			if (!usage || typeof usage.tokens !== "number" || !usage.contextWindow) return false;
 			if (usage.tokens / usage.contextWindow < loop.compactAt) return false;
 		}
-		const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
 		this.compacting = true;
 		try {
 			ctx.compact({
 				customInstructions: buildCompactionInstructions(
 					loop,
-					// A completed or otherwise finished goal is no longer the
-					// objective the summary must preserve.
-					goal?.status === "active" ? goal : undefined,
 					this.settings.compaction.instructions,
 					this.ledger,
 				),
@@ -937,7 +900,7 @@ export class LoopController {
 	 */
 	private requestReAnchor(result: unknown): void {
 		const loop = this.state;
-		if (!loop || loop.status !== "active" || !isStandaloneLoop(loop)) return;
+		if (!loop || loop.status !== "active") return;
 		const summary =
 			isRecord(result) && typeof result.summary === "string" ? result.summary : undefined;
 		this.requestContinuation(loop, "reanchor", summary ? extractNextActions(summary) : undefined);
@@ -1002,7 +965,7 @@ export class LoopController {
 			);
 			return;
 		}
-		const cap = loop.maxIterations === null ? "∞" : `${loop.maxIterations}`;
+		const cap = loop.maxTurns === null ? "∞" : `${loop.maxTurns}`;
 		const next = this.wakePending
 			? "next on idle"
 			: this.nextWakeAt
@@ -1010,7 +973,7 @@ export class LoopController {
 				: "next unscheduled";
 		ui.setStatus(
 			LOOP_STATUS_KEY,
-			`loop ${formatDuration(loop.intervalMs)} · ${loop.iteration}/${cap} · ${next}`,
+			`loop ${formatDuration(loop.intervalMs)} · ${loop.automaticTurns}/${cap} · ${next}`,
 		);
 	}
 
@@ -1032,14 +995,13 @@ export class LoopController {
 				? [`Cancelled wait (reported on the next wake): ${loop.cancelledWaitReason}`]
 				: []),
 			`Interval: every ${formatDuration(loop.intervalMs)}`,
-			`Wakes: ${loop.iteration}${loop.maxIterations === null ? " (unlimited)" : ` of ${loop.maxIterations}`}`,
-			`Automatic turns: ${loop.automaticTurns}${loop.maxAutomaticTurns === null ? " (unlimited)" : ` of ${loop.maxAutomaticTurns}`}`,
+			`Loop turns: ${loop.automaticTurns}${loop.maxTurns === null ? " (unlimited)" : ` of ${loop.maxTurns}`}`,
+			`Fallback wakes delivered: ${loop.iteration}`,
 			`Started: ${new Date(loop.startedAt).toLocaleString()}`,
 			`Expires: ${new Date(loop.expiresAt).toLocaleString()}`,
 			`Proactive compaction: ${loop.compactAt === null ? "off" : `at ${Math.round(loop.compactAt * 100)}% of context`}`,
 		];
 		if (loop.objective) {
-			lines.push("Mode: standalone (this loop owns its completion criteria)");
 			lines.push(`Objective: ${loop.objective}`);
 			if (this.ledger) {
 				const criteria = this.criteria();
@@ -1059,17 +1021,11 @@ export class LoopController {
 			} else {
 				lines.push("Ledger: unavailable (the loop runs without one)");
 			}
-		} else {
-			lines.push("Mode: goal-bound (pi-goal owns completion)");
 		}
 		if (loop.prompt) lines.push(`Focus: ${loop.prompt}`);
-		const goal = isStandaloneLoop(loop)
-			? undefined
-			: readGoalSnapshot(ctx.sessionManager.getBranch());
-		if (goal) lines.push(`Goal (pi-goal): ${goal.status} — ${goal.text}`);
 		if (this.nextWakeAt && loop.status === "active") {
 			lines.push(
-				`${isStandaloneLoop(loop) ? "Next fallback wake" : "Next wake"}: ${formatClock(this.nextWakeAt)}${
+				`Next fallback wake: ${formatClock(this.nextWakeAt)}${
 					this.noOpStreak > 0
 						? ` (backed off ×${Math.min(MAX_FALLBACK_BACKOFF, 2 ** this.noOpStreak)} after ${this.noOpStreak} no-op wake${this.noOpStreak === 1 ? "" : "s"})`
 						: ""
@@ -1090,36 +1046,29 @@ export class LoopController {
 	// --- command actions ---
 
 	/**
-	 * Mode selection, and the only place it happens.
-	 *
-	 * An active pi-goal goal wins: a bare or focused `/loop` alongside a goal
-	 * behaves exactly as it always has, and the trailing text stays a per-wake
-	 * focus. With no active goal the trailing text becomes this loop's own
-	 * objective and the loop is standalone. With neither, there is nothing to
-	 * work on, and the caller is told what to supply.
+	 * Start a loop on its own objective, the only mode there is: the trailing
+	 * text *is* what the loop works on and what `loop_complete` answers for.
+	 * With no text there is nothing to work on, and the caller is told so.
 	 */
-	startLoop(ctx: ExtensionCommandContext, start: LoopStartArguments): void {
+	startLoop(ctx: ExtensionContext, start: LoopStartArguments): LoopStartResult {
 		this.sessionCtx = ctx;
 		const now = this.now();
-		const goal = readGoalSnapshot(ctx.sessionManager.getBranch());
-		const goalBound = goal?.status === "active";
-		const objective = goalBound ? undefined : start.prompt?.trim();
-		if (!goalBound && !objective) {
-			ctx.ui.notify(
-				"A loop needs something to work on. Either give it an objective — /loop <interval> <objective with completion criteria> — or start a goal first with /goal <objective> and run /loop <interval> to bind to it.",
-				"error",
-			);
-			return;
+		const objective = start.prompt?.trim();
+		if (!objective) {
+			return {
+				ok: false,
+				message:
+					"A loop needs something to work on. Give it an objective: /loop <interval> <objective with completion criteria>.",
+			};
 		}
-		// A standalone loop with no way to call loop_complete would work, finish,
-		// and then be told to keep working until it hit a cap. Refuse at the door
-		// rather than after the first turn.
-		if (objective && !this.completeToolAvailable()) {
-			ctx.ui.notify(
-				`This session has no ${LOOP_COMPLETE_TOOL} tool, so a loop could never end itself. Re-enable it (it is excluded by --tools/--no-tools or a tool policy) and start the loop again.`,
-				"error",
-			);
-			return;
+		// A loop with no way to call loop_complete would work, finish, and then be
+		// told to keep working until it hit a cap. Refuse at the door rather than
+		// after the first turn.
+		if (!this.completeToolAvailable()) {
+			return {
+				ok: false,
+				message: `This session has no ${LOOP_COMPLETE_TOOL} tool, so a loop could never end itself. Re-enable it (it is excluded by --tools/--no-tools or a tool policy) and start the loop again.`,
+			};
 		}
 		const expiryMs =
 			start.expiresInMs ?? parseDuration(this.settings.maxLoopDuration) ?? 604_800_000;
@@ -1129,44 +1078,35 @@ export class LoopController {
 				: this.settings.compaction.enabled
 					? this.settings.compaction.threshold
 					: null;
-		this.state = {
+		const started: LoopState = {
 			id: randomUUID().slice(0, 8),
 			status: "active",
-			// The same trailing text is a per-wake focus for a goal-bound loop and
-			// the authoritative objective for a standalone one; never both.
-			...(goalBound && start.prompt ? { prompt: start.prompt } : {}),
-			...(objective ? { objective } : {}),
+			objective,
 			intervalMs: start.intervalMs,
-			maxIterations:
-				start.maxIterations !== undefined ? start.maxIterations : this.settings.maxIterations,
-			maxAutomaticTurns: this.settings.automaticTurns,
+			maxTurns: start.maxTurns !== undefined ? start.maxTurns : this.settings.maxTurns,
 			compactAt,
 			iteration: 0,
 			automaticTurns: 0,
 			startedAt: now,
 			expiresAt: now + expiryMs,
 		};
+		this.state = started;
 		this.wakePending = false;
 		this.continuationIntent = undefined;
 		this.noOpStreak = 0;
 		this.ledgerWarned = false;
-		this.openLedger(this.state);
+		this.openLedger(
+			this.state,
+			start.criteria ? criteriaFromDescriptions(start.criteria) : deriveCriteria(objective),
+		);
 		this.persist();
 		this.scheduleTick(start.intervalMs);
 		this.updateWidget();
 		const clampNote = start.clamped
 			? ` (requested ${formatDuration(start.requestedMs)}, clamped to the ${formatDuration(start.intervalMs)} minimum)`
 			: "";
-		if (goalBound) {
-			ctx.ui.notify(
-				"Binding a loop to an active /goal is deprecated and will be removed. pi-loop now owns long-running work on its own: stop the goal and run /loop <interval> <objective> instead.",
-				"warning",
-			);
-		}
 		ctx.ui.notify(
-			goalBound
-				? `Loop started: every ${formatDuration(start.intervalMs)}${clampNote}, first wake at ${formatClock(now + start.intervalMs)}, poking the active goal${start.prompt ? " with the loop focus" : ""}. Stop with /loop stop.`
-				: `Loop started: working its own objective from now, continuing at every idle boundary until the criteria are met (loop_complete), a cap is reached, or you run /loop stop. Fallback wake every ${formatDuration(start.intervalMs)}${clampNote} if the session goes quiet. Expires in ${formatDuration(expiryMs)} (one final turn to write its state down, then it stops).`,
+			`Loop started: working its objective from now, continuing at every idle boundary until the criteria are met (loop_complete), a cap is reached, or you run /loop stop. Fallback wake every ${formatDuration(start.intervalMs)}${clampNote} if the session goes quiet. Expires in ${formatDuration(expiryMs)} (one final turn to write its state down, then it stops).`,
 			"info",
 		);
 		if (this.ledger) {
@@ -1183,13 +1123,12 @@ export class LoopController {
 		// The kickoff anchor: one stored message per loop holding the objective
 		// data, because the system append exists only while the loop is active.
 		this.sendKickoffAnchor(ctx);
-		// Immediate kickoff: a standalone loop starts working now instead of
-		// burning its first interval idle. A busy session keeps the intent and
-		// delivers it at the settle.
-		if (this.state && isStandaloneLoop(this.state)) {
-			this.requestContinuation(this.state, "kickoff");
-			this.dispatchContinuationIfSettled(ctx);
-		}
+		// Immediate kickoff: the loop starts working now instead of burning its
+		// first interval idle. A busy session keeps the intent and delivers it at
+		// the settle.
+		this.requestContinuation(started, "kickoff");
+		this.dispatchContinuationIfSettled(ctx);
+		return { ok: true, loop: started };
 	}
 
 	/**
@@ -1202,7 +1141,7 @@ export class LoopController {
 	 */
 	private sendKickoffAnchor(ctx: ExtensionContext): void {
 		const loop = this.state;
-		if (!loop || !isStandaloneLoop(loop) || !this.ledger) return;
+		if (!loop || loop.objective === undefined || !this.ledger) return;
 		const idle = ctx.isIdle() && !ctx.hasPendingMessages();
 		try {
 			this.pi.sendMessage(
@@ -1241,19 +1180,6 @@ export class LoopController {
 			this.transition("stopped", "loop expired (maxLoopDuration reached)");
 			return;
 		}
-		// Same guard as startLoop, and for the same reason: resuming a goal-bound
-		// loop into a finished or missing goal would only stop or pause again at
-		// the first tick. A standalone loop owns its objective and needs no goal.
-		if (
-			!isStandaloneLoop(loop) &&
-			readGoalSnapshot(ctx.sessionManager.getBranch())?.status !== "active"
-		) {
-			ctx.ui.notify(
-				"This loop is bound to a goal, which is no longer active. Start one with /goal <objective>, then /loop resume.",
-				"error",
-			);
-			return;
-		}
 		// Resuming starts a fresh safety epoch: the user has seen why it paused
 		// and chosen to continue, so the breaker must not trip on stale counters.
 		const { pauseCause: _cause, lastFingerprint: _fingerprint, ...rest } = loop;
@@ -1263,13 +1189,11 @@ export class LoopController {
 		this.scheduleTick(loop.intervalMs);
 		this.updateWidget();
 		ctx.ui.notify(
-			isStandaloneLoop(loop)
-				? `Loop resumed: continuing now, with a fallback wake every ${formatDuration(loop.intervalMs)}.`
-				: `Loop resumed: next wake at ${formatClock(this.now() + loop.intervalMs)}.`,
+			`Loop resumed: continuing now, with a fallback wake every ${formatDuration(loop.intervalMs)}.`,
 			"info",
 		);
-		// Resuming a standalone loop resumes the work, not just the heartbeat.
-		if (this.state && isStandaloneLoop(this.state)) {
+		// Resuming resumes the work, not just the heartbeat.
+		if (this.state) {
 			this.requestContinuation(this.state);
 			this.dispatchContinuationIfSettled(ctx);
 		}