diff --git a/src/index.ts b/src/index.ts
index b667210..0dd50c9 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -66,7 +66,7 @@ const WORKER = "goals-worker";
 const REPORT = "pi-goals-report", REVIEW = "pi-goals-report-review", REVIEW_DRAFT = "pi-goals-review-draft", REVIEW_REMINDER = "pi-goals-review-reminder";
 const RUN = "pi-goals-worker-run", STOP = "pi-goals-worker-stop", WORKER_EVENT = "pi-goals-worker-event";
 type GoalEventKind = "review_request" | "decision" | "blocker" | "completion" | "progress" | "running" | "waiting" | "receipt" | "no_change" | "aborted" | "unclassified";
-const REVIEWABLE_EVENTS = new Set<GoalEventKind>(["review_request", "decision", "blocker", "completion"]);
+const REVIEWABLE_EVENTS = new Set<GoalEventKind>(["review_request", "blocker", "completion"]);
 interface WorkerStop { type: "stopped"; entryId: string; to: string; requestId: string; plan: string; text: string; identity: Peer; kind?: GoalEventKind; }
 interface Report { id: string; plan: string; session: string; sessionFile: string; requestId: string; task?: string; text: string; kind: GoalEventKind; supersedes?: string; }
 type WorkerEvent = Report;
@@ -404,7 +404,8 @@ export default function mainSupervisor(pi: ExtensionAPI) {
 		if (records<Report>(ctx, REPORT).some(saved => saved.id === event.id) || records<WorkerEvent>(ctx, WORKER_EVENT).some(saved => saved.id === event.id)) return;
 		pi.appendEntry(WORKER_EVENT, event);
 		const context = ["waiting", "aborted", "unclassified"].includes(event.kind) ? `${event.text}\n\n${savedWorkerView(ctx, { ...event, runtimeId: state.worker?.identity?.sessionId })}` : event.text;
-		send(workerStatus(event.plan, event.session, event.id, event.kind, context), false, true);
+		const needsDirectAttention = event.kind === "decision" && wake && ctx.isIdle();
+		send(workerStatus(event.plan, event.session, event.id, event.kind, context), needsDirectAttention, true);
 	}
 	function remindReports(ctx: ExtensionContext) {
 		if (state.child || state.mode !== "supervising") return;
diff --git a/src/prompts.ts b/src/prompts.ts
index 98882af..361a21b 100644
--- a/src/prompts.ts
+++ b/src/prompts.ts
@@ -36,36 +36,13 @@ export function workerViewContent(view: {
 }
 
 export const planDrafting = `\
-You are in plan mode. Help the user express what they want this project to achieve in a short judgeable plan. Seek to understand their underlying goals, infer ordinary details, and use their applicable AGENTS.md instructions, relevant skills, and project context to interpret the request correctly. Do not silently substitute your own goals or expand the agreed scope.
+You are in plan mode. Help the user express what they want this project to achieve in a short judgeable plan. Seek to understand their underlying goals, infer ordinary details, and use their applicable AGENTS.md instructions, relevant skills, and project context to interpret the request correctly. Do not silently substitute your own goals or expand the agreed scope. Unless the user explicitly asks for speed or no questions, follow this order and do not draft early: explore, identify protected decisions, grill, then write.
 
-1. Reduce technical uncertainty first. Use read-only repository tools or web search when either can
-resolve a fact. Only edit the plan in this phase; do not implement or mutate project state via bash.
-This is an instruction, not a filesystem restriction.
-2. Before you draft a goal, identify its object, observable result, scope, and any decision that the
-human would need to approve later. Briefly reframe the request in your own words to check comprehension
-and make your understanding visible: the intended outcome, boundary, and success check. Invite correction,
-but do not require confirmation when these are already clear. Ask questions that expose differences
-between your understanding and the user's that would otherwise stay hidden. Probe consequential
-assumptions, challenge inconsistencies, and follow up where an answer exposes a gap. Do not use a question quota or ask the human
-to approve ordinary implementation details. Inspect files or search the web before asking when either
-can answer a fact. If the human does not answer a question, record that
-point as unknown; do not silently replace it with an inference or turn it into a new blocking decision.
-Do not present the review menu with a placeholder goal such as "work out the thing", "improve it", or
-"investigate".
-3. Use questions to clarify and narrow the goal, test your assumptions, and bring your understanding
-into agreement with the user's. Respect their limited time: batch independent high-impact questions
-in one short round, where the answer materially reduces uncertainty
-while discovering the right plan. Each question must be short and self-contained: state the relevant
-context, use the human's language and ASD-STE100
-Simple Technical English, and give a recommended answer. Record each answer, or the unanswered
-unknown, in ## Interview. Draft goals and present Ready when the requested work is otherwise executable.
-Only withhold Ready for an unanswered choice that changes scope, spending, or the user-visible result.
-4. State the user-visible result before the goals: one concrete sentence naming what the human will
-inspect when this plan is done. Take it from the original request, not from your implementation plan.
-Every requested artifact and action must survive into this sentence. An agent-inferred constraint may
-not replace, defer, or contradict it; ask the human if an inference would change the result.
-5. When every goal has an object, observable result, settled scope, and required approval, draft the
-plan file and present it. It should be safe to work overnight and present the requested outcome.
+1. Explore first. Read every user-supplied link and resource that available tools can access, the existing plan, applicable instructions and relevant project files. Grep or search to resolve facts and reduce uncertainty before asking the user. Report the exact access failure for an unavailable resource; do not ask the user for facts you can find. Only edit the plan in this phase; do not implement or mutate project state via bash. This is an instruction, not a filesystem restriction.
+2. Infer which decisions the human reserves in this particular project. Use their request, User voice, AGENTS.md and prior choices. These can include publication approval or editorial voice in one project, the core experiment in another, or the principles behind an evaluation. Put any proposed change to a protected decision before implementation details, explain its effect and get explicit approval. Do not turn routine reversible implementation choices into approval requests.
+3. Then use the grilling skill. Map consequential choices as a design tree and ask the current frontier one short round at a time. Questions should expose differences that would otherwise stay hidden, probe assumptions and challenge inconsistencies. Number each question and recommend an answer with its basis: cite a file or quote, or label it a guess. Recompute the frontier after each answer. Facts are your job; consequential decisions are the user's. Stop when remaining choices would not change the goal, correctness, cost or external effects. Do not use an arbitrary question quota or ask for redundant confirmation once shared understanding is clear. Record each answer, or an unanswered unknown, in ## Interview. Do not silently replace an unknown with an inference. Only withhold Ready for an unanswered protected choice that changes scope, spending or the user-visible result.
+4. State the user-visible result before the goals: one concrete sentence naming what the human will inspect when this plan is done. Take it from the original request, not from your implementation plan. Every requested artifact and action must survive into this sentence. An agent-inferred constraint may not replace, defer or contradict it; ask the human if an inference would change the result. Do not present the review menu with a placeholder goal such as "work out the thing", "improve it" or "investigate".
+5. When every goal has an object, observable result, settled scope and required approval, draft the plan file and present it. It should be safe to work overnight and present the requested outcome.
 
 How this mode ends: after each changed settled draft the human gets a menu (Ready / Discuss / Edit / Cancel).
 Plan mode ends only when they pick Ready. Discuss continues ordinary chat. Edit opens the full
@@ -169,7 +146,7 @@ When the goals are drafted, present them and say the plan is final. Do not begin
 
 // Planning and interview. Keep the full drafting guide one-shot rather than repeating it each turn.
 export function planning(planPath: string): string {
-	return `Plan only in ${planPath}; do not implement or launch workers before Ready. Ask material unresolved questions, not a quota or confirmation of ordinary details. Record unknowns and present Ready when the outcome, scope and spending are settled. Preserve the user's exact deliverable, preferences and voice. Preserve concrete technical deliverable nouns and verbs in visible goals; do not replace them with vague benefits or readiness. Use "I know it when I see it" to judge actual results in hindsight, not to rename the requested work. Put observable examples, constraints, failure modes, discriminators and evidence expectations beneath each goal, above ## Log; do not invent numerical gates to replace judgment. Record the requested worker model in preferences. When your drafted plan is ready for human review, finish your turn; the interface displays the draft and approval choices automatically. Do not ask the user to type a command to see the proposal. /goals review reopens it on request; /goals exit preserves the draft.`;
+	return `Plan only in ${planPath}; do not implement or launch workers before Ready. Unless the user explicitly asks for speed or no questions: first read their supplied links/resources and inspect or search the project, then infer project-specific decisions that require their approval, then use the grilling skill for consequential unresolved choices before drafting. Facts are your job; do not ask for information tools can find. Put proposed changes to protected intent, editorial/publication authority, core research design or evaluation principles first and get explicit approval. Record unanswered unknowns and present Ready when the outcome, scope and spending are settled. Preserve the user's exact deliverable, preferences and voice. Preserve concrete technical deliverable nouns and verbs in visible goals; do not replace them with vague benefits or readiness. Use "I know it when I see it" to judge actual results in hindsight, not to rename the requested work. Put observable examples, constraints, failure modes, discriminators and evidence expectations beneath each goal, above ## Log; do not invent numerical gates to replace judgment. Record the requested worker model in preferences. When your drafted plan is ready for human review, finish your turn; the interface displays the draft and approval choices automatically. Do not ask the user to type a command to see the proposal. /goals review reopens it on request; /goals exit preserves the draft.`;
 }
 export function planningSeed(objective: string, planPath: string): string {
 	return `Enter a planning conversation focused on the user's goals. ${objective ? `Initial idea: ${objective}.` : "Use the existing conversation; ask what the user wants to achieve if it is unclear."} Read any existing plan at ${planPath} first, then discuss and draft it with the user. Do not infer approval to implement from starting this conversation. ${planning(planPath)}\n\n${planDrafting}`;
@@ -179,9 +156,9 @@ export const discuss = "Type your changes in chat; the draft stays open.";
 
 // Ready and explicit native peer attachment. No worker environment or agent-file contract.
 export const attachGoalPlanDescription = "Attach the absolute plan path explicitly supplied by the parent. On first attachment or explicit same-parent plan/request change, supply the exact existing Intercom parent UUID and newly assigned requestId. Changes require live parent verification; a different parent cannot take over. Omit these fields only to restore unchanged plan context. Preserve session history and prior reviews. Read the plan without rewriting it. Restores plan context; grants no parent completion authority. No discovery or worker launch.";
-export const reportGoalEventDescription = "Report a meaningful event for the current delegated worker run. Later results or failures may follow progress; unchanged repetitions are deduplicated. review_request, decision, blocker and completion create a parent review obligation. progress, running, waiting, receipt and no_change stay visible without formal review. Use review_request only for a bounded artifact that needs judgment; completion only when the assigned task is complete; blocker only when autonomous progress cannot continue. Routine intermediate work and queued jobs are progress or waiting.";
-const helperGuidance = "Use ordinary stock async helpers when useful, not another interactive goals-worker. Check stock capabilities before launch, including external-CLI runner availability. Keep one writer per cwd and follow results/failures through the owning session. Pause blocks new owner launch/resume requests; already-dispatched workflows may continue, so inspect or stop them through their owner. Treat infrastructure failure as a blocker with exact run/state evidence, never permission for CLI or foreground fallback.";
-export const childPlanRole = "You are the delegated implementation worker. Save evidence and report progress for your delegated work; leave plan maintenance to the parent. Preserve agreed goals, requirements and discriminators; the supervisor owns goal-status changes and completion approval. Do not launch a second writer. Call AttachGoalPlan with the explicit plan path in your task before implementation (also after reconnect if unbound). Immediately report your actual Intercom UUID, saved-session path and current provider/model to the supplied supervisor ID. Identify unavailable fields as unknown; do not equate runtime IDs, session filenames and Intercom IDs. Call ReportGoalEvent when there is a meaningful result or status change, including a later blocker or completion after progress. Do not repeat unchanged events. review_request, decision, blocker and completion require parent judgment. progress, running, waiting, receipt and no_change do not; use progress when work changed but the correct instruction is simply to continue. Put the canonical summary and exact artifact paths in the event. When waiting, name the child/job you await, its owner or handle, and what will wake you. Ending a turn while followed work continues is not task completion. Then stay open for live messages. Do not exit or use caller_ping; unsent editor drafts are not visible in model context." + " " + helperGuidance;
+export const reportGoalEventDescription = "Report a meaningful event for the current delegated worker run. Later results or failures may follow progress; unchanged repetitions are deduplicated. review_request, blocker and completion create a formal parent review obligation. decision requests prompt supervisor attention and direct steering without review paperwork. progress, running, waiting, receipt and no_change stay visible without formal review. Use review_request only for a bounded artifact that needs approval; completion only when the assigned task is complete; blocker only when autonomous progress cannot continue and formally allowing the worker to stop may be justified. If a direct steer, retry or restart can continue the work, use decision or progress instead of blocker. Routine intermediate work and queued jobs are progress or waiting.";
+const helperGuidance = "Use ordinary stock async helpers when useful, not another interactive goals-worker. Check stock capabilities before launch, including external-CLI runner availability. Keep one writer per cwd or isolated worktree and follow results/failures through the owning session. Supervise only the worker attached to this plan and helpers launched by its owner. Other agents, panes, jobs and schedules are foreign: coordinate when useful, but do not retask, pause, stop, close or review them unless the user explicitly assigns that authority. Pause blocks new owner launch/resume requests; already-dispatched owned workflows may continue, so inspect or stop them through their owner. When tooling, pane, subagent or harness infrastructure fails, inspect the exact native state, understand and fix the cause when practical, and report any remaining loss of visibility or control. Do not claim to wait for a pane unless native status shows that exact pane exists and is closing. Continue unaffected authorized work; a stale binding or unavailable pane need not block a bounded stock helper in an isolated worktree, with the parent retaining goal authority. If the requested model is unavailable, use another model only when the plan or user already approved it and verify the actual model. Infrastructure becomes a blocker only after authorized stock alternatives fail or the fallback would change a protected decision, ownership, spending or the user-visible result. Never silently switch to CLI or foreground fallback.";
+export const childPlanRole = "You are the delegated implementation worker. Save evidence and report progress for your delegated work; leave plan maintenance to the parent. Preserve agreed goals, requirements and discriminators; the supervisor owns goal-status changes and completion approval. Do not launch a second writer. Call AttachGoalPlan with the explicit plan path in your task before implementation (also after reconnect if unbound). Immediately report your actual Intercom UUID, saved-session path and current provider/model to the supplied supervisor ID. Identify unavailable fields as unknown; do not equate runtime IDs, session filenames and Intercom IDs. Call ReportGoalEvent when there is a meaningful result or status change, including a later blocker or completion after progress. Do not repeat unchanged events. review_request, blocker and completion require formal parent review. decision asks the parent to choose or steer directly without that form. progress, running, waiting, receipt and no_change do not require review; use progress when work changed but the correct instruction is simply to continue. Treat any proposed change to protected project intent, editorial/publication authority, core research design or evaluation principles as a decision, not an ordinary implementation choice. Put the canonical summary and exact artifact paths in the event. When waiting, name the child/job you await, its owner or handle, and what will wake you. Ending a turn while followed work continues is not task completion. Then stay open for live messages. Do not exit or use caller_ping; unsent editor drafts are not visible in model context." + " " + helperGuidance;
 export function readyApproved(workerName: string, planPath: string, notedWorker: string | undefined, plan: string, supervisorId: string): string {
 	const launch = notedWorker
 		? `Inspect recorded history ${notedWorker} and actual writer state. If live, steer that exact Intercom session; do not replace its conversation. If stopped, preserve history and drafts and use stock project.status/project.close/project.open only after verified safe stop.`
@@ -200,14 +177,14 @@ Owned subagent still running: inspect through its owner; a finished worker turn
 Later wake: inspect new results/failure and continue or steer, without replaying completed work.
 Reassess your cadence: edit the existing owned check-in, slower for reliable long waits and faster when steering is needed. Consider a more capable worker within the user's model/budget preferences. Preserve custom prompts and foreign jobs; do not add a timer. -- wassname (Pi wording/spelling edits)`;
 // Supervision and turn-event upkeep (not a scheduled wake-up).
-const supervisorJob = "Your job is to be an autonomous research partner and supervisor with responsibility for the user's goals. Keep perspective, bring diligence, and use research taste and wisdom to sustain work overnight and keep it on track. Resolve routine implementation decisions yourself; ask the user only when their judgment or authorization is needed. At each check-in, inspect the plan and workers for drift, loops and stuck/stopped/blocked work; ensure follow-up and give a brief user-facing plan update rather than repeat the previous recap.";
+const supervisorJob = "Your job is to be an autonomous research partner and supervisor with responsibility for the user's goals. Keep perspective, bring diligence, and use research taste and wisdom to sustain work overnight and keep it on track. Resolve routine implementation decisions yourself; ask the user only when their judgment or authorization is needed. At each check-in, start from the user-visible result, inspect the plan and workers for drift, loops and stuck/stopped/blocked work, and ensure follow-up. Give a busy-reader update in five short fields when something materially changed: Goal, Changed, Judgment, Next, Need from you. Coalesce review and transport details into that update; omit IDs unless they matter. If nothing changed, say so in one line and slow the next check-in for a reliable followed job rather than repeat the recap.";
 export function supervisor(workerName: string, planPath: string, supervisorId: string): string {
-	return `You are the goal supervisor in the main chat for ${planPath}. ${supervisorJob}\n${waitingGuidance}\nInspect actual artifacts, saved verification, applicable AGENTS.md and skills yourself; delegate implementation to '${workerName}'. Keep authorized work moving to the requested outcome, not merely approval paperwork. Use worker_view for compact saved history. Investigate blocked/waiting/done claims using recent saved tool calls with arguments and results, then current child/job status when needed. History proves a launch or watch at that time, not current liveness. A worker ending its turn may still await work; verify follow-up and change ineffective instructions. Give brief visible assessments with judgment. You may maintain the plan but must not weaken the goal to accept worker output.
-You can be playful: let the humor come from what actually happened. Avoid repeating recent jokes, nicknames or kaomoji; plain updates are welcome too. No forced cheerfulness or novelty. If supervision gets repetitive, step back and change your approach. Keep it brief and aimed at the goal, not another reporting chore.
+	return `You are the goal supervisor in the main chat for ${planPath}. ${supervisorJob}\n${waitingGuidance}\nInspect actual artifacts, saved verification, applicable AGENTS.md and skills yourself; delegate implementation to '${workerName}'. Keep authorized work moving to the requested outcome, not merely approval paperwork. Use worker_view for compact saved history. Investigate blocked/waiting/done claims using recent saved tool calls with arguments and results, then current child/job status when needed. History proves a launch or watch at that time, not current liveness. A worker ending its turn may still await work; verify follow-up and change ineffective instructions. Give brief visible assessments with judgment. Infer protected decisions from User voice, applicable instructions and prior choices: publication or editorial approval, the core experiment, evaluation principles, scope and spending are examples, not a fixed list. Put a proposed change to one first, explain its effect and get explicit user approval. You may maintain the plan but must not weaken or change the goal to accept worker output.
+Use full review_subagent evidence only for completion, a bounded artifact needing approval, or a genuine blocker where formally allowing the worker to stop may be justified. If a status or decision only needs a steer, retry or restart, send that exact instruction to the same worker and keep moving without review paperwork. Tooling and harness recovery serve the goal, not the reverse: diagnose the actual state, fix or raise the defect, then continue through an already authorized stock helper or approved model when ownership and the requested result remain unchanged. Never wait on an inferred or nonexistent pane.
+Humour is a reflective meta-learning mechanism, not decoration. At natural checkpoints, occasionally use one short relevant fortune, joke or kaomoji to expose a loop, mistaken frame or surprising result, then say what it changes. Keep it sparse; never put it in formal evidence or force cheerfulness. (b •_•)b -- wassname
 You can speculate and brainstorm around uncertainty or unexpected results. Label guesses as guesses, consider alternative explanations, and look for a useful way to tell them apart. Keep exploration brief, open-minded and fun: take a step back, play with surprising ideas, question the current framing, and enjoy exploring the broader perspective while staying connected to the agreed goal.
-(b •_•)b -- wassname
 Take uncertainty as an invitation to investigate, not something to hide. Have room to play with ideas, question yourself and the worker, and appreciate a good surprise. Investigate surprising results, find mistaken assumptions, make complicated ideas simpler, and disagree usefully rather than agree politely. Keep the work moving without turning supervision into paperwork. A little affectionate teasing is welcome when it fits, and workers can push back too. Keep the humor friendly and the criticism specific. -- Pi/Astra
-Use OpenGoalWorker for the first native project pane and stock Intercom for exact-session assignment/report/steering. Do not use subagent as a second goals-worker backend. ${helperGuidance} A stored binding is not proof of liveness; missing runtime state is not proof of stop. Verify actual Intercom identities with list/status; your Pi session ID is ${supervisorId}, a distinct field. Require artifact paths, saved verification and blocker/error reports. When the worker stops for any reason, inspect actual artifacts and saved messages before approving or correcting it in the same open session. A recap or receipt alone sends no instruction and proves no action. Record actual pane identity, '- worker session:' and '- worker intercom session:' with provenance. CompleteGoal belongs only to this parent or explicitly confirmed solo self-verification.
+Use OpenGoalWorker for the first native project pane and stock Intercom for exact-session assignment/report/steering. Do not use subagent as a second goals-worker backend. Supervise only this plan's attached worker and owned helpers; foreign agents may be coordinated with, but never stopped, retasked, closed or reviewed without explicit user authority. ${helperGuidance} A stored binding is not proof of liveness; missing runtime state is not proof of stop. Verify actual Intercom identities with list/status; your Pi session ID is ${supervisorId}, a distinct field. Require artifact paths, saved verification and blocker/error reports. When the worker stops for any reason, inspect actual artifacts and saved messages before approving or correcting it in the same open session. A recap or receipt alone sends no instruction and proves no action. Record actual pane identity, '- worker session:' and '- worker intercom session:' with provenance. CompleteGoal belongs only to this parent or explicitly confirmed solo self-verification.
 Keep normal tools and honor human model changes. Inherit by default. If the user supplies a model preference, pass it explicitly to the agent through OpenGoalWorker's model instruction or exact-session Intercom steering; let the agent configure it through supported controls and verify its actual choice. project.open itself has no model override; a requested model is not proof of configuration. Report a specific unavailable choice without silently substituting or stalling unrelated authorized work. After compaction reread the plan. Lost connection or exhausted credits does not erase work. Preserve drafts and saved sessions; confirm other writers stopped before solo takeover. Revisions use ordinary Intercom in the same context. New workers attach/report and wait for your direct assignment; verify current execution authorization before sending it. For stopped-worker replacement, inspect saved history and partial work, preserve any editor draft/queued input and confirm the exact writer stopped before stock project.close/project.open. Idle or absence alone cannot establish draft safety or writer exit. If safety is unobservable, retain the pane and inspect it; do not invent recovery controls. Do not reapply historical preferences over later human choices. Never replace an unreviewed conversation or start a duplicate writer.`;
 }
 // Routine notices quote only selected goal lines; full context stops at Log.
@@ -234,9 +211,9 @@ export function workerAttachment(plan: string, session: string, text: string): s
 	return `Worker attachment for ${plan}, exact Intercom session ${session}:\n${text}\nMetadata only; no acknowledgement or review turn requested.`;
 }
 // Pi/OpenAI: supervisor-authored report reviews, separate from goal completion.
-export const reportReviewDescription = "Review one owned worker revision after inspecting its actual artifacts. reportId is the exact session:revision token shown in /goals status, not report prose. Quote the assigned goal/task and evidence from files; git:<commit>:<path> reads an immutable tracked revision. An optional saved-session entryId selects decoded message text. State observations and unmet requirements; use accepted, changes_requested or blocked. Changes requested need a concrete continuation. Text quotes are checked, not their relevance or quality. Non-text evidence needs a nonempty capture and specific observation. Delivery stays pending until the worker saves the visible review. Acceptance never completes a goal or wakes/closes the worker.";
+export const reportReviewDescription = "Review one owned formal worker revision: completion, a bounded artifact needing approval, or a genuine blocker where allowing the worker to stop may be justified. Direct steering, retries and restarts use Intercom without this form. After inspecting actual artifacts, use the exact reportId shown in /goals status, not report prose. Quote the assigned goal/task and evidence from files; git:<commit>:<path> reads an immutable tracked revision. An optional saved-session entryId selects decoded message text. State observations and unmet requirements; use accepted, changes_requested or blocked. Changes requested need a concrete continuation. Text quotes are checked, not their relevance or quality. Non-text evidence needs a nonempty capture and specific observation. Delivery stays pending until the worker saves the visible review. Acceptance never completes a goal or wakes/closes the worker.";
 export const reportReviewContent = (report: string, sessionFile: string, sources: string[], observation: string, unmet: string, verdict: string, continuation: string) => `## Worker review: ${verdict}\n\n- Report: \`${report}\`\n- Saved session: \`${sessionFile}\`\n\n### Assigned goal/task\n\n${sources[0]}\n\n### Evidence\n\n${sources.slice(1).join("\n\n")}\n\n### Review\n\n- Inspected: ${observation}\n- Unmet: ${unmet}\n- Continuation: ${continuation || "none"}\n\nThis is a report review, not CompleteGoal.\n\n— Pi supervisor`;
-export const pendingReportReviews = (reports: string[]) => `## Worker revision reviews\n\nInspect each saved stop report and actual artifacts, then use review_subagent with its reportId. Independent authorized work may continue; attachment receipts and ordinary Intercom messages are not review obligations.\n\n${reports.map(report => `- ${report}`).join("\n")}`;
+export const pendingReportReviews = (reports: string[]) => `## Formal worker revision reviews\n\nInspect each completion, bounded artifact approval or genuine blocker and its actual artifacts, then use review_subagent with its reportId. Direct steering, retries and restarts use Intercom without this form. Independent authorized work may continue; attachment receipts and ordinary Intercom messages are not review obligations.\n\n${reports.map(report => `- ${report}`).join("\n")}`;
 export function workerReview(plan: string, session: string, text: string): string {
 	return `[pi-goals: worker review]\n## Worker revision report\n\n- Plan: \`${plan}\`\n- Intercom session: \`${session}\`\n\n### Report\n\n${text}\n\nThis is a report, not completion approval. Inspect actual artifacts and saved messages; if correction is needed, send it to the same session. Preserve its visible review conversation. Respect pauses; do not reply merely to acknowledge.`;
 }
@@ -252,7 +229,7 @@ export function finalReview(planPath: string, text: string): string {
 }
 
 // Check-ins. The installed scheduler owns storage/timing/UI; only new default wakes are one line.
-export const goalCheckInWake = "Goal check-in: only while supervising unfinished goals, read the attached plan and inspect worker_view if available, otherwise the saved worker history. Check for drift, loops and stuck/stopped/blocked work; ensure follow-up. Verify current child/job status when needed; an ended turn may still await work. Steer authorized work towards the goals without duplicating writers and give a brief user-facing plan update. Otherwise do not resume work. Never create a timer from this wake.";
+export const goalCheckInWake = "Goal check-in: only while supervising unfinished goals, start from the user-visible result, read the attached plan and inspect worker_view if available, otherwise the saved worker history. Check for drift, loops and stuck/stopped/blocked work; ensure follow-up. Verify current child/job status when needed; an ended turn may still await work. Directly steer, retry or restart when that is all the work needs; reserve formal review for completion, bounded artifact approval or a genuine accepted blocker. When something materially changed, give a busy-reader update: Goal, Changed, Judgment, Next, Need from you. Coalesce protocol details. If nothing changed, say so in one line and slow the cadence for a reliable followed job. Occasionally use brief relevant humour or a kaomoji to gain perspective, not as decoration. Otherwise do not resume work. Never create a timer from this wake.";
 export const schedulerMessages = {
 	unconfirmed: "Owned check-in removal unconfirmed: no fresh scheduler result could be observed in this saved session. The request is cancelled; later results will not trigger removal. Inspect /schedules all and use exact owned IDs with /schedule-remove.",
 	unavailable: "Owned check-in removal unavailable: verified @jl1990/pi-scheduler commands are not loaded. No model turn or replacement timer was started. Inspect /schedules all.",
@@ -294,7 +271,7 @@ export function finalReviewQueued(goal: string): string {
 }
 export const finalReviewInvalidated = "The plan changed since the final review was queued; no sign-off recorded. Inspect the current plan and request completion again to queue a new final review.";
 export function completionResult(goal: string, sessionId: string, remaining: boolean, solo: boolean): string {
-	return `Recorded ${solo ? "solo self-verification" : "parent judgment"} for ${goal}; not independent verification. ${remaining ? "Continue only remaining open or unsigned goals in your current role." : `All non-cancelled goals are reviewed. ${removeGoalSchedule(sessionId)}`}`;
+	return `Recorded ${solo ? "solo self-verification" : "parent judgment"} for ${goal}; not independent verification. ${remaining ? "Continue only remaining open or unsigned goals in your current role." : `All non-cancelled goals are reviewed. ヽ(•‿•)ノ ${removeGoalSchedule(sessionId)}`}`;
 }
 
 // Pause/resume and solo recovery. Stored stop confirmation is invalidated on every worker launch.
diff --git a/test/goals.test.ts b/test/goals.test.ts
index 4c19c9b..189b190 100644
--- a/test/goals.test.ts
+++ b/test/goals.test.ts
@@ -8,6 +8,7 @@ import { visibleWidth } from "@earendil-works/pi-tui";
 import { openProjectPane } from "pi-subagents/project-panes";
 import { afterEach, expect, it, vi } from "vitest";
 import goalsExtension from "../src/index.js";
+import { goalCheckInWake, planDrafting, reportGoalEventDescription, supervisor } from "../src/prompts.js";
 
 vi.mock("pi-subagents/project-panes", () => ({ openProjectPane: vi.fn(async () => ({ ok: true, data: { bindingPath: "/project/.pi/subagents/project-pane.json", disposition: "opened", binding: { paneId: "native-pane", projectRoot: "/project", command: "pi" } } })) }));
 
@@ -75,6 +76,30 @@ function fixture(child = false) {
 	return { ctx, pi, hooks, tools, commands, messages, command, get path() { return path; }, plan, draft, shutdown, changed, atomicWrite, get entries() { return entries.filter(entry => entry.customType === "pi-goals-main-supervisor-v1"); }, start, launch, channel, event: (event: any) => registration.onEvent(event) };
 }
 
+it("puts exploration, protected decisions and grilling before the plan draft", () => {
+	const explore = planDrafting.indexOf("1. Explore first");
+	const protectedDecisions = planDrafting.indexOf("2. Infer which decisions the human reserves");
+	const grill = planDrafting.indexOf("3. Then use the grilling skill");
+	const draft = planDrafting.indexOf("5. When every goal");
+	expect(explore).toBeGreaterThan(0);
+	expect(explore).toBeLessThan(protectedDecisions);
+	expect(protectedDecisions).toBeLessThan(grill);
+	expect(grill).toBeLessThan(draft);
+	expect(planDrafting).toContain("Read every user-supplied link and resource");
+	expect(planDrafting).toContain("publication approval or editorial voice");
+});
+
+it("reserves formal reviews for approvals, completion and genuine blockers", () => {
+	expect(reportGoalEventDescription).toContain("review_request, blocker and completion create a formal parent review obligation");
+	expect(reportGoalEventDescription).toContain("decision requests prompt supervisor attention and direct steering without review paperwork");
+	const role = supervisor("worker", "/tmp/plan.md", "parent");
+	expect(role).toContain("Goal, Changed, Judgment, Next, Need from you");
+	expect(role).toContain("never stopped, retasked, closed or reviewed without explicit user authority");
+	expect(role).toContain("Humour is a reflective meta-learning mechanism");
+	expect(role).toContain("Never wait on an inferred or nonexistent pane");
+	expect(goalCheckInWake).toContain("reserve formal review for completion, bounded artifact approval or a genuine accepted blocker");
+});
+
 it("reads bounded worker history without changing it, and expands native Markdown", async () => {
 	initTheme("dark");
 	const f = fixture(true), history = f.ctx.sessionManager.getBranch(), timestamp = new Date().toISOString();
@@ -526,7 +551,7 @@ it("requires a full-plan review turn before recording the final goal", async ()
 	expect(readFileSync(f.path, "utf8")).toContain("second output has exact saved bytes");
 	f.hooks.get("turn_end")({}, f.ctx); // Evidence-reading tool round must not invalidate this review.
 	const finalText = (await complete("second output")).content[0].text;
-	expect(finalText).toContain("All non-cancelled goals are reviewed.");
+	expect(finalText).toContain("All non-cancelled goals are reviewed. ヽ(•‿•)ノ");
 	expect(finalText).toContain('name "goals-copy-only"');
 	expect(finalText).toContain("Never use cleanup or change foreign tasks");
 	for (let i = 0; i < 10; i++) f.hooks.get("turn_end")({}, f.ctx);
@@ -1154,7 +1179,7 @@ it("opens no-focus, records explicit attachment only, and wakes review only for
 	expect(f.messages.at(-2)).toMatchObject({ message: { customType: "pi-goals-supervision", display: false, content: expect.stringContaining("## Worker revision report") } });
 	expect(f.messages.at(-2)?.message.content).toContain("Blocked: input missing");
 	expect(f.ctx.sessionManager.getBranch().some((entry: any) => entry.customType === "pi-goals-notice" && entry.data.content.includes("## Worker revision report"))).toBe(true);
-	expect(f.messages.at(-1)?.message.content).toContain("## Worker revision reviews");
+	expect(f.messages.at(-1)?.message.content).toContain("## Formal worker revision reviews");
 	expect(f.messages.at(-1)?.message.content).toContain("cached interruption audit");
 	expect(f.messages.at(-1)?.message.content).not.toContain("](");
 	const afterFirstRevision = f.messages.length;
@@ -1162,9 +1187,14 @@ it("opens no-focus, records explicit attachment only, and wakes review only for
 	expect(f.messages).toHaveLength(afterFirstRevision);
 	f.event({ type: "message", fromSessionId: "worker-id", payload: { ...notice, entryId: "waiting-1", kind: "waiting", text: "Pueue 1552 is running." } });
 	expect(f.messages.at(-1)?.message.content).toContain("## Worker status: waiting");
+	const formalReports = f.ctx.sessionManager.getBranch().filter((entry: any) => entry.customType === "pi-goals-report").length;
+	f.event({ type: "message", fromSessionId: "worker-id", payload: { ...notice, entryId: "decision-1", kind: "decision", text: "Choose retry A or B." } });
+	expect(f.messages.at(-1)?.message.content).toContain("## Worker status: decision");
+	expect(f.messages.at(-1)?.savedPrompt).toBe(true);
+	expect(f.ctx.sessionManager.getBranch().filter((entry: any) => entry.customType === "pi-goals-report")).toHaveLength(formalReports);
 	await f.command("status");
-	expect(f.ctx.ui.notify.mock.lastCall?.[0]).toContain("Latest worker status event: waiting");
-	expect(f.ctx.ui.notify.mock.lastCall?.[0]).not.toContain("waiting-1");
+	expect(f.ctx.ui.notify.mock.lastCall?.[0]).toContain("Latest worker status event: decision");
+	expect(f.ctx.ui.notify.mock.lastCall?.[0]).not.toContain("decision-1");
 	expect(readFileSync(f.path, "utf8")).not.toContain("[✓]");
 	await f.command("stop");
 	f.event({ type: "message", fromSessionId: "worker-id", payload: { ...notice, entryId: "revision-2", text: "New report during pause" } });