@hank-warren/pi-loop 0.5.0 → 0.6.0

package/src/inline-invocation.ts

@@ -0,0 +1,109 @@
+/**
+ * Inline `/loop` invocation, tool-mediated.
+ *
+ * Pi only dispatches `/loop` when it starts the message. When the user writes
+ * `quick check /loop 10m get CI green` or a `loop:` prefixed line mid-prompt,
+ * this module appends a one-turn reminder to the system prompt so the model
+ * reliably calls the `loop_start` tool with the objective. The user's message
+ * itself is never touched — no cutting, splitting, re-sending, or visible
+ * annotation — so there are no delivery races, no message loss, and no
+ * transcript noise: guidance is injected at agent-start time, not by
+ * rewriting input.
+ *
+ * Two hooks cooperate because neither alone is safe:
+ * - `input` carries a `source` and so can tell user-typed text from
+ *   extension-sent prompts, but any transform it returns rewrites the stored,
+ *   visible user message. It only records the armed text here.
+ * - `before_agent_start` can extend the system prompt, but fires for
+ *   extension-sent prompts too, and pi-loop's own kickoff and continuation
+ *   prompts contain phrases like "the active /loop objective" that the
+ *   detector would match. It injects only when the starting prompt *is* the
+ *   armed user message, and disarms on every start, matched or not.
+ *
+ * Two deliberate limits keep the armed window one turn wide:
+ * - Streaming-typed input (`streamingBehavior` set, i.e. steered or queued)
+ *   never arms. Pi returns from `prompt()` before `before_agent_start` for
+ *   those, so an armed flag would survive to a later, unrelated turn — the
+ *   window through which pi-loop's own continuation prompts could be matched.
+ * - The hint is a per-turn `systemPrompt` append, not a stored message, so
+ *   "call loop_start now" cannot linger in the conversation and fire on a
+ *   later turn.
+ *
+ * The armed flag is also the `loop_start` tool's gate: unlike pi-goal, which
+ * relied on prompt guidelines alone, a loop is self-continuing, so this
+ * extension *enforces* that the tool only runs on a turn the user explicitly
+ * invoked. See `InlineInvocationState.invokedThisTurn`.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { detectsInlineInvocation } from "./inline-command.js";
+import type { LoopController } from "./loop.js";
+
+export const INLINE_LOOP_COMMAND = "loop";
+
+export const INLINE_LOOP_HINT =
+	"<system-reminder>The user's message this turn inline-invoked a loop (/loop or loop:). Call the loop_start tool now with the objective text that follows the token in that message, then begin working toward it. Do not answer the objective as prose without starting the loop. If the message is discussing, quoting, or documenting the /loop command rather than invoking it, do not call loop_start. This reminder applies only to the user's message this turn.</system-reminder>";
+
+/**
+ * The armed state, shared between the hooks and the `loop_start` tool.
+ *
+ * `invokedThisTurn` is the hard gate: set when `before_agent_start` matched
+ * the armed user message, cleared at `agent_end` and at every session
+ * boundary. `loop_start` refuses whenever it is false, so no amount of prompt
+ * drift, transcript replay, or model initiative can start a self-continuing
+ * loop the user did not ask for.
+ */
+export class InlineInvocationState {
+	invokedThisTurn = false;
+}
+
+export function registerInlineInvocation(
+	pi: ExtensionAPI,
+	controller: LoopController,
+	state: InlineInvocationState,
+) {
+	let armedText: string | undefined;
+
+	pi.on("input", (event) => {
+		// Extension-sourced messages (loop kickoffs, continuations, pokes, other
+		// extensions' injections) never arm the hint.
+		if (event.source === "extension") return;
+		// Steered or queued input returns from prompt() without ever reaching
+		// before_agent_start, so arming it would leave stale text armed.
+		if (event.streamingBehavior !== undefined) return;
+		if (!controller.settings.inlineInvocation) return;
+		if (!detectsInlineInvocation(event.text, INLINE_LOOP_COMMAND)) return;
+		armedText = event.text;
+	});
+
+	pi.on("before_agent_start", (event) => {
+		const armed = armedText;
+		armedText = undefined;
+		// Every start closes the previous turn's window, so a turn that ends
+		// without an agent_end still cannot leave the tool unlocked.
+		state.invokedThisTurn = false;
+		if (armed === undefined) return;
+		if (!controller.settings.inlineInvocation) return;
+		if (!promptCarriesArmedMessage(event.prompt, armed)) return;
+		state.invokedThisTurn = true;
+		return { systemPrompt: `${event.systemPrompt}\n\n${INLINE_LOOP_HINT}` };
+	});
+
+	const disarm = () => {
+		armedText = undefined;
+		state.invokedThisTurn = false;
+	};
+	pi.on("agent_end", disarm);
+	pi.on("session_start", disarm);
+	pi.on("session_shutdown", disarm);
+}
+
+/**
+ * True when the starting prompt is the armed user message. Pi may wrap the
+ * text with expanded prefixes or suffixes, so the armed text has to be the
+ * whole prompt or one of its ends — mirroring how upstream recognises its own
+ * owned prompts at a terminal boundary.
+ */
+function promptCarriesArmedMessage(prompt: string, armed: string) {
+	return prompt === armed || prompt.startsWith(armed) || prompt.endsWith(armed);
+}

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,
@@ -54,7 +46,6 @@ import {
 	buildCompactionInstructions,
 	buildContinuation,
 	buildExpiryWake,
-	buildGoalPoke,
 	buildKickoffAnchor,
 	buildObjectivePoke,
 	type ContinuationKind,
@@ -67,10 +58,8 @@ import {
 	readLoopSettings,
 } from "./settings.js";
 import {
-	isStandaloneLoop,
 	LOOP_STATE_ENTRY_TYPE,
 	type LoopState,
-	readGoalSnapshot,
 	readPlanModeEnabled,
 	restoreLoopState,
 } from "./state.js";
@@ -106,6 +95,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 +189,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 +211,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 +230,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 +382,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 +435,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 +452,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 +506,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,9 +567,9 @@ 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.
 	 */
 	private openLedger(loop: LoopState): void {
 		if (loop.objective === undefined) {
@@ -729,7 +712,6 @@ export class LoopController {
 			busy: !ctx.isIdle() || ctx.hasPendingMessages(),
 			compacting: this.compacting,
 			planModeEnabled: readPlanModeEnabled(branch),
-			goal: readGoalSnapshot(branch),
 		};
 	}
 
@@ -757,7 +739,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 +749,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":
@@ -777,19 +759,9 @@ export class LoopController {
 			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`,
+					decision.reason === "max-automatic-turns"
+						? `the ${loop.maxAutomaticTurns}-automatic-turn cap was reached`
+						: `the ${loop.maxIterations}-iteration cap was reached`,
 				);
 				return;
 		}
@@ -841,20 +813,11 @@ export class LoopController {
 	 * 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.
 	 */
-	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 +835,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 +857,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 +896,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);
@@ -1039,7 +998,6 @@ export class LoopController {
 			`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 +1017,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 +1042,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,13 +1074,10 @@ 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,
@@ -1146,6 +1088,7 @@ export class LoopController {
 			startedAt: now,
 			expiresAt: now + expiryMs,
 		};
+		this.state = started;
 		this.wakePending = false;
 		this.continuationIntent = undefined;
 		this.noOpStreak = 0;
@@ -1157,16 +1100,8 @@ export class LoopController {
 		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 +1118,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 +1136,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 +1175,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 +1184,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);
 		}