@oh-my-pi/pi-coding-agent 16.1.5 → 16.1.6

package/dist/types/modes/interactive-mode.d.ts

@@ -177,7 +177,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
      * user submits becomes the new loop prompt and resumes iteration.
      */
     pauseLoop(): void;
-    handleLoopCommand(args?: string): Promise<void>;
+    handleLoopCommand(args?: string): Promise<string | undefined>;
     recordLocalSubmission(text: string, imageCount?: number): () => void;
     withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: {
         imageCount?: number;

package/dist/types/modes/loop-limit.d.ts

@@ -14,7 +14,20 @@ export type LoopLimitRuntime = {
     durationMs: number;
     deadlineMs: number;
 };
-export declare function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string;
+export interface ParsedLoopArgs {
+    /** Iteration/duration budget, when the user supplied a leading limit token. */
+    limit?: LoopLimitConfig;
+    /** Inline loop prompt: text after the limit, or the whole argument when no limit was given. */
+    prompt?: string;
+}
+/**
+ * Parse `/loop` arguments into an optional leading limit plus an optional inline
+ * prompt. A token that *looks* like a limit (starts with a digit or sign) but
+ * fails to parse is a hard error; anything else is treated as prompt text, so
+ * plain prose after `/loop` keeps starting an unbounded loop instead of erroring
+ * (the pre-arg-parsing behavior). Returns the error message string on failure.
+ */
+export declare function parseLoopLimitArgs(args: string): ParsedLoopArgs | string;
 export declare function createLoopLimitRuntime(config: LoopLimitConfig | undefined, nowMs?: number): LoopLimitRuntime | undefined;
 export declare function consumeLoopLimitIteration(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;
 export declare function isLoopDurationExpired(limit: LoopLimitRuntime | undefined, nowMs?: number): boolean;

package/dist/types/modes/types.d.ts

@@ -339,7 +339,7 @@ export interface InteractiveModeContext {
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;
     handleGuidedGoalCommand(rest?: string): Promise<void>;
-    handleLoopCommand(args?: string): Promise<void>;
+    handleLoopCommand(args?: string): Promise<string | undefined>;
     disableLoopMode(): void;
     pauseLoop(): void;
     handlePlanApproval(details: PlanApprovalDetails): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.5",
+	"version": "16.1.6",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.5",
-		"@oh-my-pi/omp-stats": "16.1.5",
-		"@oh-my-pi/pi-agent-core": "16.1.5",
-		"@oh-my-pi/pi-ai": "16.1.5",
-		"@oh-my-pi/pi-catalog": "16.1.5",
-		"@oh-my-pi/pi-mnemopi": "16.1.5",
-		"@oh-my-pi/pi-natives": "16.1.5",
-		"@oh-my-pi/pi-tui": "16.1.5",
-		"@oh-my-pi/pi-utils": "16.1.5",
-		"@oh-my-pi/pi-wire": "16.1.5",
-		"@oh-my-pi/snapcompact": "16.1.5",
+		"@oh-my-pi/hashline": "16.1.6",
+		"@oh-my-pi/omp-stats": "16.1.6",
+		"@oh-my-pi/pi-agent-core": "16.1.6",
+		"@oh-my-pi/pi-ai": "16.1.6",
+		"@oh-my-pi/pi-catalog": "16.1.6",
+		"@oh-my-pi/pi-mnemopi": "16.1.6",
+		"@oh-my-pi/pi-natives": "16.1.6",
+		"@oh-my-pi/pi-tui": "16.1.6",
+		"@oh-my-pi/pi-utils": "16.1.6",
+		"@oh-my-pi/pi-wire": "16.1.6",
+		"@oh-my-pi/snapcompact": "16.1.6",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/modes/interactive-mode.ts

@@ -1128,27 +1128,33 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#cancelLoopAutoSubmit();
 	}
 
-	async handleLoopCommand(args = ""): Promise<void> {
+	async handleLoopCommand(args = ""): Promise<string | undefined> {
 		if (this.loopModeEnabled) {
 			this.disableLoopMode();
-			return;
+			return undefined;
 		}
-		const parsedLimit = parseLoopLimitArgs(args);
-		if (typeof parsedLimit === "string") {
-			this.showError(parsedLimit);
-			return;
+		const parsed = parseLoopLimitArgs(args);
+		if (typeof parsed === "string") {
+			this.showError(parsed);
+			return undefined;
 		}
 		this.loopModeEnabled = true;
 		this.loopPrompt = undefined;
-		this.loopLimit = createLoopLimitRuntime(parsedLimit);
+		this.loopLimit = createLoopLimitRuntime(parsed.limit);
 		this.statusLine.setLoopModeStatus({ enabled: true });
 		this.updateEditorTopBorder();
 		this.ui.requestRender();
-		const limitSuffix = parsedLimit ? ` Limited to ${describeLoopLimit(parsedLimit)}.` : "";
+		const limitSuffix = parsed.limit ? ` Limited to ${describeLoopLimit(parsed.limit)}.` : "";
 		const remainingSuffix = this.loopLimit ? ` ${describeLoopLimitRuntime(this.loopLimit)}.` : "";
+		const tail = parsed.prompt ? "Repeating it after each turn." : "Your next prompt will repeat after each turn.";
 		this.showStatus(
-			`Loop mode enabled.${limitSuffix}${remainingSuffix} Your next prompt will repeat after each turn. Esc cancels the current iteration; /loop again to disable.`,
+			`Loop mode enabled.${limitSuffix}${remainingSuffix} ${tail} Esc cancels the current iteration; /loop again to disable.`,
 		);
+		// Hand any inline prompt back to the dispatcher so the normal submit flow
+		// runs the first iteration — it records the text as the loop prompt and
+		// auto-resubmits it after each yield, identical to typing the prompt right
+		// after enabling loop mode.
+		return parsed.prompt;
 	}
 
 	recordLocalSubmission(text: string, imageCount = 0): () => void {

package/src/modes/loop-limit.ts

@@ -38,53 +38,105 @@ const TIME_UNITS_MS = new Map<string, number>([
 	["hours", 3_600_000],
 ]);
 
-export function parseLoopLimitArgs(args: string): LoopLimitConfig | undefined | string {
-	const trimmed = args.trim().toLowerCase();
-	if (!trimmed) return undefined;
+const LOOP_USAGE = "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
 
-	const parts = trimmed.split(/\s+/);
-	if (parts.length > 2) {
-		return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
-	}
+export interface ParsedLoopArgs {
+	/** Iteration/duration budget, when the user supplied a leading limit token. */
+	limit?: LoopLimitConfig;
+	/** Inline loop prompt: text after the limit, or the whole argument when no limit was given. */
+	prompt?: string;
+}
 
-	if (parts.length === 2) {
-		return parseDurationParts(parts[0], parts[1]);
+/**
+ * Parse `/loop` arguments into an optional leading limit plus an optional inline
+ * prompt. A token that *looks* like a limit (starts with a digit or sign) but
+ * fails to parse is a hard error; anything else is treated as prompt text, so
+ * plain prose after `/loop` keeps starting an unbounded loop instead of erroring
+ * (the pre-arg-parsing behavior). Returns the error message string on failure.
+ */
+export function parseLoopLimitArgs(args: string): ParsedLoopArgs | string {
+	const trimmed = args.trim();
+	if (!trimmed) return {};
+
+	const firstSpace = trimmed.search(/\s/);
+	const firstToken = firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+	const rest = firstSpace === -1 ? "" : trimmed.slice(firstSpace + 1).trim();
+	const token = firstToken.toLowerCase();
+
+	// Not a limit attempt (prose like "keep going") → unbounded loop, prompt = full args.
+	if (!/^[+-]?\d/.test(token)) {
+		return { prompt: trimmed };
 	}
 
-	const token = parts[0];
-	const iterationMatch = /^(\d+)$/.exec(token);
-	if (iterationMatch) {
-		const iterations = Number(iterationMatch[1]);
-		if (!Number.isSafeInteger(iterations) || iterations <= 0) {
-			return "Loop count must be a positive integer.";
+	// Bare integer: iteration count, unless the next token is a time unit ("10 minutes").
+	if (/^\d+$/.test(token)) {
+		if (rest) {
+			const restTokens = rest.split(/\s+/);
+			const unitMs = TIME_UNITS_MS.get(restTokens[0].toLowerCase());
+			if (unitMs !== undefined) {
+				const limit = makeDuration(token, unitMs);
+				if (typeof limit === "string") return limit;
+				return { limit, prompt: restTokens.slice(1).join(" ").trim() || undefined };
+			}
 		}
-		return { kind: "iterations", iterations };
+		const limit = makeIterations(token);
+		if (typeof limit === "string") return limit;
+		return { limit, prompt: rest || undefined };
 	}
 
-	const durationMatch = /^(\d+)([a-z]+)$/.exec(token);
-	if (durationMatch) {
-		return parseDurationParts(durationMatch[1], durationMatch[2]);
+	// Compact / compound duration: "10m", "90s", "1h30m".
+	const duration = parseCompoundDuration(token);
+	if (duration !== undefined) {
+		if (typeof duration === "string") return duration;
+		return { limit: duration, prompt: rest || undefined };
 	}
 
-	return "Usage: /loop [count|duration]. Examples: /loop 10, /loop 10m, /loop 10min.";
+	// Limit-shaped but unparseable ("-1", "1.5h", "10x10").
+	return LOOP_USAGE;
 }
 
-function parseDurationParts(amountText: string, unitText: string): LoopLimitConfig | string {
-	if (!/^\d+$/.test(amountText)) {
-		return "Loop duration must use a positive integer amount.";
+function makeIterations(amountText: string): LoopLimitConfig | string {
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount <= 0) {
+		return "Loop count must be a positive integer.";
 	}
+	return { kind: "iterations", iterations: amount };
+}
 
+function makeDuration(amountText: string, unitMs: number): LoopLimitConfig | string {
 	const amount = Number(amountText);
 	if (!Number.isSafeInteger(amount) || amount <= 0) {
 		return "Loop duration must be positive.";
 	}
+	return { kind: "duration", durationMs: amount * unitMs };
+}
 
-	const unitMs = TIME_UNITS_MS.get(unitText);
-	if (unitMs === undefined) {
-		return "Loop duration unit must be seconds, minutes, or hours.";
+/**
+ * Parse a compact duration token such as `10m`, or a compound one like `1h30m`.
+ * Returns `undefined` when the token is not duration-shaped, or an error string
+ * when it is shaped like a duration but uses an unknown unit / non-positive
+ * amount.
+ */
+function parseCompoundDuration(token: string): LoopLimitConfig | string | undefined {
+	if (!/^(?:\d+[a-z]+)+$/.test(token)) return undefined;
+	const segments = token.match(/\d+[a-z]+/g);
+	if (!segments) return undefined;
+	let totalMs = 0;
+	for (const segment of segments) {
+		const match = /^(\d+)([a-z]+)$/.exec(segment);
+		if (!match) return LOOP_USAGE;
+		const unitMs = TIME_UNITS_MS.get(match[2]);
+		if (unitMs === undefined) {
+			return "Loop duration unit must be seconds, minutes, or hours.";
+		}
+		const amount = Number(match[1]);
+		if (!Number.isSafeInteger(amount) || amount <= 0) {
+			return "Loop duration must be positive.";
+		}
+		totalMs += amount * unitMs;
 	}
-
-	return { kind: "duration", durationMs: amount * unitMs };
+	if (totalMs <= 0) return "Loop duration must be positive.";
+	return { kind: "duration", durationMs: totalMs };
 }
 
 export function createLoopLimitRuntime(

package/src/modes/types.ts

@@ -362,7 +362,7 @@ export interface InteractiveModeContext {
 	handlePlanModeCommand(initialPrompt?: string): Promise<void>;
 	handleGoalModeCommand(rest?: string): Promise<void>;
 	handleGuidedGoalCommand(rest?: string): Promise<void>;
-	handleLoopCommand(args?: string): Promise<void>;
+	handleLoopCommand(args?: string): Promise<string | undefined>;
 	disableLoopMode(): void;
 	pauseLoop(): void;
 	handlePlanApproval(details: PlanApprovalDetails): Promise<void>;

package/src/prompts/system/system-prompt.md

@@ -22,7 +22,7 @@ Use tools whenever they improve correctness, completeness, or grounding.
 - SHOULD resolve prerequisites before acting.
 - NEVER stop at the first plausible answer if another call would cut uncertainty.
 - Empty, partial, or suspiciously narrow lookup? Retry a different strategy.
-- SHOULD parallelize independent calls.
+- SHOULD parallelize calls when possible.
 {{#has tools "task"}}- User says `parallel`/`parallelize` → MUST use `{{toolRefs.task}}` subagents; parallel tool calls alone do not satisfy.{{/has}}
 
 # I/O
@@ -78,17 +78,28 @@ Pattern syntax (metavariables, `$$$` spreads) is in each tool's description.
 {{#has tools "task"}}
 # Eager Tasks
 {{#if eagerTasksAlways}}
-Delegation is the default, not the exception. Once the design is settled, you MUST fan work out to `{{toolRefs.task}}` subagents rather than doing it yourself. Work alone ONLY when one is unambiguously true:
-- a single-file edit under ~30 lines
-- a direct answer needing no code changes
-- the user explicitly asked you to run a command yourself
-Everything else — multi-file changes, refactors, features, tests, investigations — MUST be decomposed and delegated.{{#if taskBatch}} Batch independent slices into one parallel `{{toolRefs.task}}` call; never serialize what can run concurrently.{{/if}}
+Delegation is the default here, not the exception. Once the design is settled, you MUST fan the work out to `{{toolRefs.task}}` subagents rather than doing it yourself. Work alone ONLY when one of these is unambiguously true:
+- A single-file edit under ~30 lines
+- A direct answer or explanation requiring no code changes
+- The user explicitly asked you to run a command yourself
+Everything else — multi-file changes, refactors, new features, tests, investigations — MUST be decomposed and delegated.{{#if taskBatch}} Batch independent slices into one parallel `{{toolRefs.task}}` call; never serialize what can run concurrently.{{/if}}
 {{else}}
-Delegation is preferred. Once the design is settled, you SHOULD fan substantial work out to `{{toolRefs.task}}` subagents — multi-file changes, refactors, features, tests, investigations are strong candidates. Use judgment for small, single-file, or interactive work.{{#if taskBatch}} Batch independent slices into one parallel `{{toolRefs.task}}` call rather than serializing them.{{/if}}
+Delegation is preferred here. Once the design is settled, you SHOULD fan substantial work out to `{{toolRefs.task}}` subagents instead of doing everything yourself — multi-file changes, refactors, new features, tests, and investigations are strong candidates. Use your judgment for small, single-file, or interactive work.{{#if taskBatch}} When you delegate independent slices, batch them into one parallel `{{toolRefs.task}}` call rather than serializing them.{{/if}}
 {{/if}}
 {{/has}}
 {{/if}}
 
+{{#has tools "task"}}
+<parallel-reflex>
+When work forks, you MUST fork. Guard against the sequential habit: comfort in one-thing-at-a-time, the illusion that order = correctness, the assumption that B depends on A.
+ALWAYS use `{{toolRefs.task}}` to launch subagents when work forks into independent streams:
+- editing 4+ files with no dependencies between edits
+- investigating multiple subsystems
+- work that decomposes into independent pieces
+Sequential work MUST be justified. If you cannot articulate why B depends on A, you MUST parallelize.
+</parallel-reflex>
+{{/has}}
+
 {{#if toolInfo.length}}
 # Inventory
 {{#if mcpDiscoveryMode}}

package/src/prompts/tools/task.md

@@ -1,68 +1,68 @@
-{{#if asyncEnabled}}{{#if batchEnabled}}Spawns subagents in the background — one per `tasks[]` item; single spawn = one-item batch.{{else}}Spawns ONE subagent per call in the background.{{/if}}
+{{#if asyncEnabled}}{{#if batchEnabled}}Spawns subagents to work in the background — one per `tasks[]` item; a single spawn is a one-item batch.{{else}}Spawns ONE subagent per call to work in the background.{{/if}}
 
-- Non-blocking: returns agent id{{#if batchEnabled}}s{{/if}} + job id{{#if batchEnabled}}s{{/if}} immediately; each result auto-delivered on yield.
+- Spawning is non-blocking: the call returns immediately with the agent id{{#if batchEnabled}}s{{/if}} and job id{{#if batchEnabled}}s{{/if}}; each result is delivered automatically when that agent yields.
 - Parallelism = {{#if batchEnabled}}multiple `tasks[]` items in ONE call. MUST batch into one `tasks[]` (share `context` once). Separate `task` calls ONLY for a different `agent` type or unrelated `context`{{else}}multiple `task` calls in one assistant message{{/if}}.
-- Blocked on a result? `job poll`; else keep working. `job cancel` kills a task, **cannot carry a message** — only for stalled/abandoned work.
-{{else}}{{#if batchEnabled}}Runs subagents synchronously — one per `tasks[]` item; single spawn = one-item batch.{{else}}Runs ONE subagent synchronously per call.{{/if}}
+- If genuinely blocked on a result, wait with `job poll`; otherwise keep working. `job cancel` terminates a task and **cannot carry a message** — only for stalled/abandoned work.
+{{else}}{{#if batchEnabled}}Runs subagents synchronously — one per `tasks[]` item; a single spawn is a one-item batch.{{else}}Runs ONE subagent synchronously per call.{{/if}}
 
-- Blocking: returns only after the agent{{#if batchEnabled}}s{{/if}} finish; results arrive inline.
+- Spawning is blocking: the call returns only after the agent{{#if batchEnabled}}s{{/if}} finish; results arrive inline.
 - Parallelism = {{#if batchEnabled}}multiple `tasks[]` items in ONE call. MUST batch into one `tasks[]` (share `context` once). Separate `task` calls ONLY for a different `agent` type or unrelated `context`{{else}}multiple `task` calls in one assistant message{{/if}}.
 {{/if}}
 {{#if ircEnabled}}
-- Coordinate via `irc` by agent id; agents reach you + siblings live.
+- Coordinate with agents via `irc` using their ids. Agents reach you and their siblings live the same way.
 {{/if}}
 
 <parameters>
 - `agent`: agent type to spawn
 {{#if batchEnabled}}
-- `context`: background prepended to every assignment — goal, constraints, contract (see context-fmt); REQUIRED, session-specific only
-- `tasks`: one subagent per item, all in parallel:
-  - `assignment`: complete self-contained instructions; one-liners / missing acceptance criteria PROHIBITED
-  - `id`: stable agent id, CamelCase, ≤32 chars; auto when omitted
+- `context`: shared background prepended to every assignment — goal, constraints, shared contract (see context-fmt); REQUIRED, session-specific only
+- `tasks`: tasks to spawn — one subagent per item, all in parallel:
+  - `assignment`: complete self-contained instructions; one-liners and missing acceptance criteria are PROHIBITED
+  - `id`: stable agent id, CamelCase, ≤32 chars; generated when omitted
   - `description`: UI label only — subagent never sees it
-  - `role`: specialist identity (e.g. "Auth-flow security reviewer") — sets system-prompt persona + roster name
+  - `role`: specialist identity this subagent embodies (e.g. "Auth-flow security reviewer") — sets its system-prompt persona and roster display name; tailor every spawn rather than cloning a generic worker
 {{#if isolationEnabled}}
-  - `isolated`: run spawn in isolated env; returns patches. Torn down at completion — not addressable after
+  - `isolated`: run this spawn in an isolated env; returns patches. Isolated agents are torn down at completion — not addressable afterwards
 {{/if}}
 {{else}}
-- `id`: stable agent id, CamelCase, ≤32 chars; auto when omitted
+- `id`: stable agent id, CamelCase, ≤32 chars; generated when omitted
 - `description`: UI label only — subagent never sees it
-- `role`: specialist identity (e.g. "Auth-flow security reviewer") — sets system-prompt persona + roster name
-- `assignment`: complete self-contained instructions; one-liners / missing acceptance criteria PROHIBITED
+- `role`: specialist identity this subagent embodies (e.g. "Auth-flow security reviewer") — sets its system-prompt persona and roster display name; tailor every spawn rather than cloning a generic worker
+- `assignment`: complete self-contained instructions; one-liners and missing acceptance criteria are PROHIBITED
 {{#if isolationEnabled}}
-- `isolated`: run in isolated env; returns patches. Torn down at completion — not addressable after
+- `isolated`: run in isolated env; returns patches. Isolated agents are torn down at completion — not addressable afterwards
 {{/if}}
 {{/if}}
 </parameters>
 
 <rules>
-- **Maximize fan-out.** Widest {{#if batchEnabled}}`tasks[]` batch{{else}}set of parallel `task` calls{{/if}} the work decomposes into. NEVER serialize parallelizable work.
-- **Subagents do not verify, lint, or format.** Each assignment MUST tell the subagent: skip all gates, formatters, project-wide build/test/lint. You run them once at the end across changed files.
+- **Maximize fan-out.** Issue the widest {{#if batchEnabled}}`tasks[]` batch{{else}}set of parallel `task` calls{{/if}} the work decomposes into. NEVER serialize work that could run concurrently.
+- **Subagents do not verify, lint, or format.** Every assignment MUST instruct the subagent to skip all gates, formatters, and project-wide build/test/lint. You run them once at the end across the union of changed files.
 - No globs, no "update all", no package-wide scope. Fan out.
-- **Tailor every spawn with a `role`.** A named specialist (e.g. "Parser edge-case tester", "SSE backpressure specialist") beats a generic `task`/`quick_task` worker; decompose into specialists, never clones. Role-less spawn is the exception.
-- NEVER serialize over possible file overlap. Agents self-resolve collisions in real time.
-- Subagents have no conversation history. Every fact, file path, direction MUST be explicit in {{#if batchEnabled}}`context` or the item's `assignment`{{else}}the `assignment`{{/if}}.
+- **Tailor every spawn with a `role`.** A role naming the specialist (e.g. "Parser edge-case tester", "SSE backpressure specialist") makes a sharper agent than a bare generic `task`/`quick_task` worker; decompose into named specialists, never clones of one generic worker. A role-less generic spawn is the exception.
+- NEVER slow down or serialize because tasks might overlap on some files. Agents resolve collisions among themselves in real time.
+- Subagents have no conversation history. Every fact, file path, and direction they need MUST be explicit in {{#if batchEnabled}}`context` or the item's `assignment`{{else}}the `assignment`{{/if}}.
 {{#if batchEnabled}}
-- **Shared background** in `context` once, never per assignment. Large payloads via `local://<path>` URIs, not inline.
+- **Shared background** lives in `context` once — never duplicated across assignments. Pass large payloads via `local://<path>` URIs, not inline.
 {{else}}
-- **Shared background**: write ONCE to a `local://` file (e.g. `local://ctx.md`), reference it in each assignment. Large payloads via `local://<path>` URIs, not inline.
+- **Shared background**: write it ONCE to a `local://` file (e.g. `local://ctx.md`) and reference that path in each assignment. Pass large payloads via `local://<path>` URIs, not inline.
 {{/if}}
-- Prefer agents that investigate **and** edit in one pass; spin a read-only discovery step only when affected files unknown.
-- **Read-only agents** (e.g. `explore`): no edit/write/command tools. NEVER assign them file changes or commands. Use to investigate + report; delegate edits to a writing agent (`task`/`oracle`/`designer`) or do them yourself.
-- **No reasoning offload**: NEVER route reasoning, analysis, design, or decisions to `quick_task`/`explore` — minimal-effort / small models for mechanical lookups + data collection only. Keep judgment + synthesis in your own context; delegate hard thinking to `task`/`plan`/`oracle`.
+- Prefer agents that investigate **and** edit in one pass; only spin a read-only discovery step when affected files are genuinely unknown.
+- **Read-only agents**: Agents tagged READ-ONLY (e.g. `explore`) have no edit/write/command tools. NEVER hand them an assignment that requires changing files or running commands. Use them to investigate and report back; do the edits yourself or delegate to a writing agent (`task`, `oracle`, `designer`).
+- **No reasoning offload**: NEVER offload reasoning, analysis, design, or decision-making to `quick_task` or `explore` — they run minimal-effort / small models for mechanical lookups and data collection only. Keep judgment and synthesis in your own context; delegate hard thinking to `task`, `plan`, or `oracle`.
 </rules>
 
 <parallelization>
 {{#if ircEnabled}}
-Test: can B run without A's output? No → sequence A → B — **unless** B can ask A over `irc`. Live coordination beats a waterfall when the contract is small + DM-able.
-Still sequence when a task produces a large evolving contract (generated types, schema migration, core module API) consumed wholesale — IRC round-trips don't replace a finished artifact.
-Parallel when tasks touch disjoint files, are independent refactors/tests, or need only occasional peer clarification.
+Test: can task B run correctly without seeing A's output? If no, sequence A → B — **unless** B can reasonably ask A for the missing piece over `irc`. Live coordination beats a serial waterfall when the contract is small and easy to describe in a DM.
+Still sequence when one task produces a large, evolving contract (generated types, schema migration, core module API) the other consumes wholesale — IRC round-trips do not replace a finished artifact.
+Parallel when tasks touch disjoint files, are independent refactors/tests, or only need occasional clarification that can be resolved peer-to-peer.
 {{else}}
-Test: can B run without A's output? No → sequence A → B.
+Test: can task B run correctly without seeing A's output? If no, sequence A → B.
 Sequential when one task produces a contract (types, API, schema, core module) the other consumes.
 Parallel when tasks touch disjoint files or are independent refactors/tests.
 {{/if}}
-{{#if ircEnabled}}Sequenced follow-ups SHOULD message the prerequisite's producer — it holds the context.{{/if}}
+{{#if ircEnabled}}Sequenced follow-ups SHOULD message the agent that produced the prerequisite — it already holds the context.{{/if}}
 </parallelization>
 
 {{#if batchEnabled}}

package/src/slash-commands/builtin-registry.ts

@@ -306,11 +306,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		name: "loop",
 		description:
 			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
-		inlineHint: "[count|duration]",
+		inlineHint: "[count|duration] [prompt]",
 		allowArgs: true,
 		handleTui: async (command, runtime) => {
-			await runtime.ctx.handleLoopCommand(command.args);
+			const prompt = await runtime.ctx.handleLoopCommand(command.args);
 			runtime.ctx.editor.setText("");
+			// Surface any inline prompt so the dispatcher returns it and the normal
+			// submit flow runs the first loop iteration (recording it as the loop prompt).
+			if (prompt) return { prompt };
 		},
 	},
 	{