@agent-plan/pi-adapter 0.2.22 → 0.2.23-next.0

package/dist/index.js

@@ -9,12 +9,14 @@
  *  - inject context into prompts
  */
 import { Type } from "typebox";
-import { ExportService, PlanStore, setWriteBusyHook, setWriteNotifyHook, withFeatureLock, needsMotivation, findPhaseByRef, findTaskByRef, buildRecap, addChecklistItem, removeChecklistItem, toggleChecklistItem, buildPhaseContextBlock, checkExplicitTaskStart, recommendNextTask, packageVersionFromModule, resolvedPackageVersion } from "@agent-plan/core";
+import { paginatedSelect, paginatedNotify } from "./ui/paginate.js";
+import { ExportService, PlanStore, setWriteBusyHook, setWriteNotifyHook, withFeatureLock, needsMotivation, findPhaseByRef, findTaskByRef, buildRecap, addChecklistItem, removeChecklistItem, toggleChecklistItem, buildPhaseContextBlock, checkExplicitTaskStart, recommendNextTask, buildResumeRequiredProposal, packageVersionFromModule, resolvedPackageVersion, markFeatureReadForSessionId, markPhaseReadForSessionId, markTaskReadForSessionId, contextReadEligibilityForSession, hasValidSessionAttestation, hasReadRequirementsForSession, markRequirementReadForSessionId, startReadSession, invalidateReads, taskStartDenied, taskStartSucceeded } from "@agent-plan/core";
 import { createChecklistItemId, createFeatureId, createPhaseId, createTaskId, clampSlug, normalizeSlug, formatPhaseRef, formatFeatureRef, featureNumberOfPhase, validateResolvedTarget } from "@agent-plan/core/naming";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { writeFile, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { createServer } from "node:net";
 import { fileURLToPath } from "node:url";
 import { serve } from "@agent-plan/server/serve";
@@ -28,6 +30,7 @@ let capturedPi = null;
 let store = null;
 let server = null;
 let lastKnownWebPort = null;
+let plannerSessionId = randomUUID();
 // True while the agent is mutating .planner/ files. The web server returns 503-busy
 // during this window so the UI doesn't render inconsistent data.
 let planBusy = false;
@@ -38,6 +41,20 @@ function withPlanBusy(fn) {
         .then(() => fn())
         .finally(() => { planBusy = false; });
 }
+function taskStartFailure(outcome, details = {}) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: [
+                    `❌ TASK START FAILED [${outcome.errorCode}]`,
+                    "started: false",
+                    outcome.message,
+                    "No task lifecycle transition was applied.",
+                    "Next required actions:",
+                    ...outcome.nextActions.map((action, index) => `${index + 1}. ${action}`),
+                ].join("\n") }],
+        details: { ...outcome, ...details },
+    };
+}
 // Helper to notify a running server in another process via HTTP.
 async function notifyExternalServer() {
     try {
@@ -134,7 +151,7 @@ const PLANNER_COMMAND_COMPLETIONS = [
     { value: "task checklist-remove", label: "task checklist-remove", description: "Remove a step: /planner task checklist-remove <T00x> <C{n}|title>" },
     { value: "task checklist-toggle", label: "task checklist-toggle", description: "Tick/untick a step: /planner task checklist-toggle <T00x> <C{n}|title> [on|off]" },
     { value: "handoff list", label: "handoff list", description: "List phases with a handoff" },
-    { value: "handoff prepare", label: "handoff prepare", description: "Tell the agent to write the handoff (legacy file-based)" },
+    { value: "handoff prepare", label: "handoff prepare", description: "Audit and reconcile the active phase handoff with durable entity context" },
     { value: "handoff show", label: "handoff show [P00x]", description: "Show a phase handoff (phase ref required)" },
     { value: "handoff write", label: "handoff write [P00x]", description: "Write a phase handoff after confirmation (phase ref required)" },
     { value: "handoff clear", label: "handoff clear [P00x]", description: "Archive a phase handoff (phase ref required)" },
@@ -243,10 +260,11 @@ async function getPlannerExecutionGuard(st) {
         ? allTasks.find(({ task }) => task.id === resume.inProgressTaskIds[0])
         : undefined;
     const focusFromCurrentPhase = resume?.currentPhaseId
-        ? allTasks.find(({ phase, task }) => phase.id === resume.currentPhaseId && task.status !== "done" && task.status !== "canceled")
+        ? allTasks.find(({ phase, task }) => phase.id === resume.currentPhaseId && task.status !== "done" && task.status !== "canceled" && task.status !== "rejected")
         : undefined;
-    const fallbackFocus = allTasks.find(({ task }) => task.status === "planned" || task.status === "blocked")
-        ?? allTasks.find(({ task }) => task.status !== "done" && task.status !== "canceled");
+    const fallbackFocus = allTasks.find(({ task }) => task.pauseSnapshot)
+        ?? allTasks.find(({ task }) => task.status === "planned" || task.status === "blocked" || task.status === "waiting")
+        ?? allTasks.find(({ task }) => task.status !== "done" && task.status !== "canceled" && task.status !== "rejected");
     const focus = focusFromResume ?? focusFromCurrentPhase ?? fallbackFocus;
     return {
         totalTasks,
@@ -317,7 +335,8 @@ async function buildHandoffMarkdown(st, reason, overrides) {
         ?? null;
     const currentTask = currentPhase?.tasks.find((task) => resume.inProgressTaskIds.includes(task.id))
         ?? currentPhase?.tasks.find((task) => task.status === "in-progress")
-        ?? [...(currentPhase?.tasks ?? [])].filter((task) => task.status !== "done" && task.status !== "canceled").sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0]
+        ?? currentPhase?.tasks.find((task) => task.pauseSnapshot)
+        ?? [...(currentPhase?.tasks ?? [])].filter((task) => task.status !== "done" && task.status !== "canceled" && task.status !== "rejected").sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0]
         ?? latestTaskUpdate?.task
         ?? null;
     const currentFeature = currentPhase?.featureId
@@ -555,6 +574,7 @@ function statusIcon(status) {
     const icons = {
         draft: "📄", discovery: "🔍", planned: "📋",
         "in-progress": "🚧", done: "✅", blocked: "🚫", canceled: "❌",
+        rejected: "❌", deferred: "⏳", waiting: "⏱️",
     };
     return icons[status] ?? "❓";
 }
@@ -626,20 +646,40 @@ function resolveStaticDir() {
         const adapterDir = dirname(adapterFile);
         // When installed as Pi package: node_modules/@agent-plan/pi-adapter/web-ui-dist/
         const pkgWebUi = join(adapterDir, "..", "web-ui-dist");
-        if (existsSync(pkgWebUi))
-            return pkgWebUi;
-        // Fallback: monorepo dev — packages/plan-web-ui/dist/
-        return join(adapterDir, "..", "..", "plan-web-ui", "dist");
+        // Monorepo dev: packages/plan-web-ui/dist/ (rebuilt by `pnpm build:web-ui`)
+        const devWebUi = join(adapterDir, "..", "..", "plan-web-ui", "dist");
+        const candidates = [pkgWebUi, devWebUi].filter((d) => {
+            try {
+                return existsSync(join(d, "index.html"));
+            }
+            catch {
+                return false;
+            }
+        });
+        if (candidates.length === 0)
+            return undefined;
+        if (candidates.length === 1)
+            return candidates[0];
+        // Prefer the most recently built bundle so a fresh `pnpm build:web-ui`
+        // (or copy-web-ui.sh) is picked up in dev instead of a stale vendored
+        // snapshot. Deterministic: compare index.html mtimes, newest wins.
+        const mtime = (d) => {
+            try {
+                return statSync(join(d, "index.html")).mtimeMs;
+            }
+            catch {
+                return 0;
+            }
+        };
+        return [...candidates].sort((a, b) => mtime(b) - mtime(a))[0];
     }
     catch {
         return undefined;
     }
 }
 async function maybeStartWeb(ctx) {
-    if (server) {
-        plannerSessionEnabled = true;
+    if (server)
         return;
-    }
     ctx.ui.notify("Starting web server (LAN)…", "info");
     try {
         await startServer(ctx, undefined, "lan");
@@ -661,7 +701,6 @@ function normalizeVisibility(input) {
     return undefined;
 }
 async function startServer(ctx, requestedPort, visibility = "lan") {
-    plannerSessionEnabled = true;
     if (server)
         return;
     const host = visibility === "lan" ? "0.0.0.0" : "127.0.0.1";
@@ -733,6 +772,10 @@ async function startServer(ctx, requestedPort, visibility = "lan") {
         catch { }
     }
 }
+function enablePlannerSession() {
+    plannerSessionEnabled = true;
+    contextBlockDirty = true;
+}
 function disablePlannerSession() {
     plannerSessionEnabled = false;
     startupResumePromptPending = false;
@@ -759,6 +802,9 @@ export default function planPiExtension(pi) {
     capturedPi = pi;
     // ── Restore on session start/reload ─────────────────────────────────
     pi.on("session_start", async (_event, ctx) => {
+        plannerSessionId = randomUUID();
+        invalidateReads();
+        startReadSession(plannerSessionId);
         try {
             ctx.ui.addAutocompleteProvider((current) => ({
                 triggerCharacters: ["/", " "],
@@ -1134,6 +1180,7 @@ export default function planPiExtension(pi) {
                 await st.writeGenerated();
                 await scanCodebase();
                 ctx.ui.notify(`.planner/ initialized for "${name.trim()}". Starting project discuss…`, "info");
+                enablePlannerSession();
                 await maybeStartWeb(ctx);
                 await handlePlanner("project discuss", ctx);
                 return;
@@ -1151,6 +1198,7 @@ export default function planPiExtension(pi) {
             await st.writeGenerated();
             await scanCodebase();
             ctx.ui.notify(`.planner/ initialized for "${name.trim()}". Starting project discuss…`, "info");
+            enablePlannerSession();
             await maybeStartWeb(ctx);
             await handlePlanner("project discuss", ctx);
             return;
@@ -1182,12 +1230,12 @@ export default function planPiExtension(pi) {
                 .sort((a, b) => a.number - b.number);
             if (features.length === 0)
                 return null;
-            const options = features.map((f) => `  ${formatFeatureRef(f.number)} ${statusIcon(f.status)} ${f.name}${f.shortId ? ` · ${f.shortId}` : ""}`);
-            const chosen = await ctx.ui.select("Pick a feature", options);
-            if (chosen == null)
-                return null;
-            const idx = options.indexOf(chosen);
-            return idx >= 0 ? features[idx] : null;
+            return paginatedSelect(ctx, {
+                title: "Pick a feature",
+                items: features,
+                render: (f) => `  ${formatFeatureRef(f.number)} ${statusIcon(f.status)} ${f.name}${f.shortId ? ` · ${f.shortId}` : ""}`,
+                pageSize: 10,
+            });
         }
         // ═══════════════════════════════════════════════════════════════
         //  Helper: pick a phase interactively
@@ -1198,12 +1246,12 @@ export default function planPiExtension(pi) {
                 return null;
             }
             const features = (await st.loadFeatures().catch(() => ({ features: [] }))).features;
-            const options = phases.map((p) => `  ${formatPhaseRef(p.number, featureNumberOfPhase(p, features))} ${statusIcon(p.status)} ${p.title}${p.shortId ? ` · ${p.shortId}` : ""}`);
-            const chosen = await ctx.ui.select("Pick a phase", options);
-            if (chosen == null)
-                return null;
-            const idx = options.indexOf(chosen);
-            return idx >= 0 ? phases[idx] : null;
+            return paginatedSelect(ctx, {
+                title: "Pick a phase",
+                items: phases,
+                render: (p) => `  ${formatPhaseRef(p.number, featureNumberOfPhase(p, features))} ${statusIcon(p.status)} ${p.title}${p.shortId ? ` · ${p.shortId}` : ""}`,
+                pageSize: 10,
+            });
         }
         // ═══════════════════════════════════════════════════════════════
         //  Helper: pick a task interactively from a phase
@@ -1212,12 +1260,12 @@ export default function planPiExtension(pi) {
             if (phase.tasks.length === 0)
                 return null;
             const tasks = phase.tasks.slice().sort((a, b) => a.number - b.number);
-            const options = tasks.map((t) => `  T${String(t.number).padStart(3, "0")} ${statusIcon(t.status)} ${t.title}${t.shortId ? ` · ${t.shortId}` : ""}`);
-            const chosen = await ctx.ui.select(`Pick a task from "${phase.title}"`, options);
-            if (chosen == null)
-                return null;
-            const idx = options.indexOf(chosen);
-            return idx >= 0 ? tasks[idx] : null;
+            return paginatedSelect(ctx, {
+                title: `Pick a task from "${phase.title}"`,
+                items: tasks,
+                render: (t) => `  T${String(t.number).padStart(3, "0")} ${statusIcon(t.status)} ${t.title}${t.shortId ? ` · ${t.shortId}` : ""}`,
+                pageSize: 10,
+            });
         }
         function parseMultilineList(value) {
             return (value ?? "")
@@ -1435,9 +1483,9 @@ export default function planPiExtension(pi) {
             if (b === "language") {
                 const project = await st.loadProject();
                 const contentLanguage = await ctx.ui.input(`Plan content language [${project.contentLanguage || "English"}]`);
-                const chatLanguage = await ctx.ui.input(`Chat language [${project.chatLanguage || contentLanguage?.trim() || project.contentLanguage || "Italian"}]`);
+                const chatLanguage = await ctx.ui.input(`Chat language [${project.chatLanguage || contentLanguage?.trim() || project.contentLanguage || "English"}]`);
                 project.contentLanguage = contentLanguage?.trim() || project.contentLanguage || "English";
-                project.chatLanguage = chatLanguage?.trim() || project.chatLanguage || project.contentLanguage || "Italian";
+                project.chatLanguage = chatLanguage?.trim() || project.chatLanguage || project.contentLanguage || "English";
                 await st.saveProject(project);
                 await st.writeGenerated();
                 ctx.ui.notify(`Saved language preferences: content=${project.contentLanguage}, chat=${project.chatLanguage}`, "info");
@@ -1461,11 +1509,12 @@ export default function planPiExtension(pi) {
                     return;
                 }
                 const phases = await st.loadAllPhases();
-                ctx.ui.notify(features.map((feature) => {
+                const lines = features.map((feature) => {
                     const featurePhases = phases.filter((phase) => phase.featureId === feature.id);
                     const taskCount = featurePhases.reduce((total, phase) => total + phase.tasks.length, 0);
                     return `${statusIcon(feature.status)} ${feature.name} (${feature.id}) — ${featurePhases.length} phases, ${taskCount} tasks`;
-                }).join("\n"), "info");
+                });
+                await paginatedNotify(ctx, { title: "features", lines, pageSize: 10 });
                 return;
             }
             if (b === "add") {
@@ -1506,6 +1555,7 @@ export default function planPiExtension(pi) {
                     phaseIds: [],
                     dependsOn: [],
                     statusLog: [],
+                    sessionInfo: [],
                     createdAt: now,
                     updatedAt: now,
                 };
@@ -1727,6 +1777,7 @@ export default function planPiExtension(pi) {
                         handoffReadAt: "",
                         handoffHistory: [],
                         statusLog: [],
+                        sessionInfo: [],
                     };
                     await st.savePhase(phase);
                     await st.updateFeatures((doc) => {
@@ -1967,6 +2018,7 @@ export default function planPiExtension(pi) {
                     descriptionUpdatedAt: "",
                     notes: "",
                     statusLog: [],
+                    sessionInfo: [],
                     decisions: [],
                     acceptedDecisions: [],
                     checklist: [], subtasks: [],
@@ -2129,8 +2181,13 @@ export default function planPiExtension(pi) {
                         ctx.ui.notify(`Invalid status. Use: ${valid.join(", ")}`, "error");
                         return;
                     }
-                    if (normalizedStatus === "in-progress" && (await st.listHandoffs()).length > 0) {
-                        ctx.ui.notify("ℹ️  One or more phases have a pending handoff — if relevant to this task, read it with /planner handoff show <ref>, then clear with /planner handoff clear. Proceeding with the status change.", "info");
+                    if (normalizedStatus === "in-progress" && normalizedStatus !== task.status) {
+                        ctx.ui.notify("Task start/resume transitions require /planner task start so ordered full context reads and lifecycle state remain consistent.", "warning");
+                        return;
+                    }
+                    if (normalizedStatus === "done" && normalizedStatus !== task.status) {
+                        ctx.ui.notify("Task completion requires /planner task complete with durable completion and verification evidence.", "warning");
+                        return;
                     }
                     applyTaskLifecycleDates(task, normalizedStatus, now);
                 }
@@ -2168,6 +2225,38 @@ export default function planPiExtension(pi) {
                         return;
                     }
                 }
+                if (phase) {
+                    const features = (await st.loadFeatures()).features;
+                    const feature = phase.featureId ? features.find((candidate) => candidate.id === phase.featureId) : undefined;
+                    const linkedRequirements = [
+                        ...(await st.linkedRequirementsForPhase(phase.id)),
+                        ...(phase.featureId ? await st.linkedRequirementsForFeature(phase.featureId) : []),
+                    ].filter((requirement, index, all) => all.findIndex((candidate) => candidate.id === requirement.id) === index);
+                    const linkedRequirementIds = linkedRequirements.map((requirement) => requirement.id);
+                    const contextInput = {
+                        sessionId: plannerSessionId,
+                        taskId: task.id,
+                        phaseId: phase.id,
+                        ...(phase.featureId ? { featureId: phase.featureId } : {}),
+                        task,
+                        phase,
+                        ...(feature ? { feature } : {}),
+                        requirements: linkedRequirements,
+                        requirementIds: linkedRequirementIds,
+                    };
+                    const contextEligibility = contextReadEligibilityForSession(contextInput);
+                    if (!contextEligibility.eligible) {
+                        ctx.ui.notify(`❌ TASK START FAILED [CONTEXT_READ_REQUIRED]\nstarted: false\n${contextEligibility.reason}\nRead task(full), phase(full), feature(full) in order, then retry.`, "error");
+                        return;
+                    }
+                    if (!hasReadRequirementsForSession(plannerSessionId, linkedRequirementIds, linkedRequirements)) {
+                        ctx.ui.notify("❌ TASK START FAILED [REQUIREMENTS_READ_REQUIRED]\nstarted: false\nRun requirement_list, then retry /planner task start. The task remains unchanged.", "error");
+                        return;
+                    }
+                    if (!hasValidSessionAttestation(contextInput)) {
+                        await st.recordContextRead({ sessionId: plannerSessionId, phaseId: phase.id, taskId: task.id, ...(phase.featureId ? { featureId: phase.featureId } : {}), requirementIds: linkedRequirementIds });
+                    }
+                }
                 if (task.status === "in-progress") {
                     ctx.ui.notify(`Task "${task.title}" is already in-progress.`, "info");
                     return;
@@ -2232,6 +2321,11 @@ export default function planPiExtension(pi) {
                         return;
                     }
                 }
+                const completionSummary = await ctx.ui.input("Completion summary (shipped work, verification, remaining/unverified, files/decisions)");
+                if (!completionSummary?.trim() || completionSummary.trim().length < 10) {
+                    ctx.ui.notify("Completion cancelled — provide a durable summary of at least 10 characters.", "warning");
+                    return;
+                }
                 const now = nowISO();
                 // Record status change in the incremental statusLog.
                 const entry = {
@@ -2240,12 +2334,16 @@ export default function planPiExtension(pi) {
                     fromStatus: task.status,
                     toStatus: "done",
                     title: `→ done`,
-                    description: "",
+                    description: completionSummary.trim(),
                 };
                 task.statusLog = [...(task.statusLog ?? []), entry];
                 applyTaskLifecycleDates(task, "done", now);
+                const separator = task.description ? "\n\n---\n**Completion summary:**\n" : "**Completion summary:**\n";
+                task.description = `${task.description}${separator}${completionSummary.trim()}`;
+                task.descriptionUpdatedAt = now;
                 task.updatedAt = now;
                 phase.updatedAt = now;
+                await st.savePhase(phase);
                 const clearedRef = await st.syncTaskStatusRollup(phase.id);
                 await st.writeGenerated();
                 ctx.ui.notify(`✅ Task completed: ${formatPhaseRef(phase.number, featureNumberOfPhase(phase, (await st.loadFeatures()).features))}/T${String(task.number).padStart(3, "0")} — ${task.title} (done)${task.shortId ? ` · ${task.shortId}` : ""}${clearedRef ? ` — phase handoff archived (${clearedRef})` : ""}`, "info");
@@ -2341,7 +2439,11 @@ export default function planPiExtension(pi) {
                     ctx.ui.notify("No phase handoffs set.", "info");
                     return;
                 }
-                ctx.ui.notify(list.map((e) => `• ${e.compositeRef} — ${e.firstLine} (updated ${e.updatedAt})`).join("\n"), "info");
+                await paginatedNotify(ctx, {
+                    title: "phase handoffs",
+                    lines: list.map((e) => `• ${e.compositeRef} — ${e.firstLine} (updated ${e.updatedAt})`),
+                    pageSize: 10,
+                });
                 return;
             }
             if (action === "show") {
@@ -2355,23 +2457,7 @@ export default function planPiExtension(pi) {
                 return;
             }
             if (action === "write") {
-                const r = await resolvePhaseForHandoff(st, phaseRef);
-                if (!r.ok) {
-                    ctx.ui.notify(r.error, "warning");
-                    return;
-                }
-                const text = await ctx.ui.input(`Handoff text for ${r.compositeRef}`);
-                if (!text?.trim()) {
-                    ctx.ui.notify("No text provided; nothing written.", "info");
-                    return;
-                }
-                const confirmed = await ctx.ui.confirm(`Write this handoff on ${r.compositeRef}?`, "Write handoff");
-                if (!confirmed) {
-                    ctx.ui.notify("Handoff write cancelled.", "info");
-                    return;
-                }
-                await st.setPhaseHandoff(r.phase.id, text);
-                ctx.ui.notify(`Wrote handoff on ${r.compositeRef}`, "info");
+                ctx.ui.notify("Direct handoff writes are disabled because they bypass durable task/phase/feature context synchronization. Use /planner handoff prepare, confirm the exact phase, then let the agent run handoff_prepare and handoff_write.", "warning");
                 return;
             }
             if (action === "prepare") {
@@ -2381,15 +2467,16 @@ export default function planPiExtension(pi) {
                 }
                 await capturedPi.sendUserMessage("Prepare a canonical session handoff proposal. Do not write anything yet. First identify from this conversation and the latest planner lifecycle events the exact feature and phase where the decisions/work belong. Never use the first in-progress phase or a stale resume pointer as a target.\n\n" +
                     "If the last phase was just completed, do not create an operational handoff for it; its existing handoff must have been archived by the phase-done lifecycle. If another non-done phase is the real continuation, identify that phase explicitly.\n\n" +
-                    "Before calling `handoff_write`, tell the user exactly: `I propose writing this handoff on P00x(F00x) — <phase title>. Confirm?` Wait for an explicit confirmation. Only after confirmation call `handoff_write` with that exact phaseRef. If the target is ambiguous, ask the user to identify the feature and phase instead of guessing.\n\n" +
-                    "After confirmation, the handoff MUST contain at minimum:\n" +
+                    "Before writing, tell the user exactly: `I propose writing this handoff on P00x(F00x) — <phase title>. Confirm?` Wait for an explicit confirmation. If the target is ambiguous, ask the user to identify the feature and phase instead of guessing.\n\n" +
+                    "After confirmation, call `handoff_prepare` with that exact phaseRef. Read the entire existing handoff and its handoffUpdatedAt token. Audit every listed done task that lacks durable completion/verification evidence. Then call `handoff_write` with the exact token, one reconciled handoff body, taskUpdates for every missing task, and either durable phase/feature updates or explicit no-update reasons. Never overwrite an existing handoff without retaining its still-relevant decisions, solved problems, architecture, files, and constraints. Replace stale focus, blockers, and next steps.\n\n" +
+                    "The reconciled handoff MUST contain at minimum:\n" +
                     "- `Created at:` and `Updated at:` lines (ISO timestamps)\n" +
                     "- `Reason:` why this handoff is being written\n" +
                     "- `## Current focus`: feature, phase and task refs/titles/statuses derived from the confirmed target\n" +
                     "- `## What was being done`: the concrete decisions/work from this session\n" +
                     "- `## How to resume`: explicit ordered steps\n" +
                     "- `## Files touched`, `## Blockers`, `## Next steps`, and `## Recent decisions`\n" +
-                    "Pass a meaningful title beginning with the confirmed phase ref. Generic titles are rejected. Handoffs are stored on phase.handoff; `.planner/HANDOFF.md` is deprecated.");
+                    "Pass a meaningful title beginning with the confirmed phase ref. Generic titles are rejected. Handoff refresh synchronizes durable task/phase/feature context and updates the single active phase.handoff; `.planner/HANDOFF.md` is deprecated.");
                 ctx.ui.notify("Instructing the agent to prepare the phase handoff…", "info");
                 return;
             }
@@ -2514,7 +2601,7 @@ export default function planPiExtension(pi) {
             return;
         }
         if (a === "load") {
-            plannerSessionEnabled = true;
+            enablePlannerSession();
             if (!server) {
                 ctx.ui.notify("Starting web server (LAN) …", "info");
                 await startServer(ctx, undefined, "lan").catch(() => { });
@@ -2682,6 +2769,7 @@ export default function planPiExtension(pi) {
                         status: "planned",
                         macroTasks: [],
                         linkedPhaseIds: [],
+                        sessionInfo: [],
                         createdAt: now,
                         updatedAt: now,
                     })),
@@ -2747,6 +2835,7 @@ export default function planPiExtension(pi) {
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
             const requirements = await st.loadRequirements();
+            requirements.requirements.forEach((req) => markRequirementReadForSessionId(plannerSessionId, req.id));
             return {
                 content: [{ type: "text", text: requirements.requirements.map((req) => `- ${req.id} — ${req.title} (${req.status})`).join("\n") || "No requirements" }],
                 details: requirements,
@@ -2767,15 +2856,22 @@ export default function planPiExtension(pi) {
             const st = await requirePlan(ctx);
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
+            const title = params.title?.trim();
+            if (!title)
+                return { content: [{ type: "text", text: "title required" }], details: {} };
+            const links = await resolveRequirementPhaseRefs(st, params.linkedPhaseIds);
+            if (!links.ok)
+                return { content: [{ type: "text", text: links.error }], details: {} };
             const requirements = await st.loadRequirements();
             const now = nowISO();
             const requirement = {
                 id: createRequirementId(),
-                title: params.title.trim(),
+                title,
                 description: params.description?.trim() ?? "",
                 status: params.status?.trim() ?? "planned",
                 macroTasks: [],
-                linkedPhaseIds: (params.linkedPhaseIds ?? []).map((entry) => entry.trim()).filter(Boolean),
+                linkedPhaseIds: links.linkedPhaseIds,
+                sessionInfo: [],
                 createdAt: now,
                 updatedAt: now,
             };
@@ -2804,14 +2900,22 @@ export default function planPiExtension(pi) {
             const requirement = requirements.requirements.find((entry) => entry.id === params.requirementId);
             if (!requirement)
                 return { content: [{ type: "text", text: `Requirement not found: ${params.requirementId}` }], details: {} };
-            if (params.title !== undefined)
-                requirement.title = params.title.trim();
+            if (params.title !== undefined) {
+                const title = params.title.trim();
+                if (!title)
+                    return { content: [{ type: "text", text: "title required" }], details: {} };
+                requirement.title = title;
+            }
             if (params.description !== undefined)
                 requirement.description = params.description.trim();
             if (params.status !== undefined)
                 requirement.status = params.status.trim();
-            if (params.linkedPhaseIds !== undefined)
-                requirement.linkedPhaseIds = params.linkedPhaseIds.map((entry) => entry.trim()).filter(Boolean);
+            if (params.linkedPhaseIds !== undefined) {
+                const links = await resolveRequirementPhaseRefs(st, params.linkedPhaseIds);
+                if (!links.ok)
+                    return { content: [{ type: "text", text: links.error }], details: {} };
+                requirement.linkedPhaseIds = links.linkedPhaseIds;
+            }
             requirement.updatedAt = nowISO();
             await st.saveRequirements(requirements);
             await st.writeGenerated();
@@ -2945,7 +3049,7 @@ export default function planPiExtension(pi) {
     pi.registerTool({
         name: "plan_write_handoff",
         label: "Plan Write Handoff",
-        description: "DEPRECATED — writes to the entity-scoped phase.handoff (not .planner/HANDOFF.md). Prefer handoff_write. phaseRef is required and must be the exact phase confirmed with the user; never infer a target from current status or resume pointers. Completed/canceled phases reject new handoffs.",
+        description: "DEPRECATED AND WRITE-DISABLED — retained only for proposal compatibility. Use handoff_prepare followed by handoff_write so durable task/phase/feature context is synchronized and existing handoff content is reconciled.",
         parameters: Type.Object({
             phaseRef: Type.String({ description: "Exact confirmed phase ref: P00x | P00x(F00x) | UUID | title." }),
             confirmed: Type.Boolean({ description: "Set true only after the user explicitly confirms the proposed feature+phase target." }),
@@ -2967,21 +3071,10 @@ export default function planPiExtension(pi) {
                 return { content: [{ type: "text", text: `⚠️ plan_write_handoff is deprecated (writes to phase.handoff, not .planner/HANDOFF.md). ${resolved.error}` }], details: { deprecated: true, error: resolved.error } };
             if (!params.confirmed)
                 return { content: [{ type: "text", text: `Proposal only: I would write this handoff on ${resolved.compositeRef}. Ask the user to confirm this exact feature/phase, then retry with confirmed=true.` }], details: { deprecated: true, phaseRef: resolved.compositeRef, confirmationRequired: true } };
-            const markdown = await buildHandoffMarkdown(st, params.reason?.trim() || "manual tool handoff", {
-                phaseId: resolved.phase.id,
-                ...(params.title?.trim() ? { title: params.title.trim() } : {}),
-                ...(params.whatWasBeingDone?.trim() ? { whatWasBeingDone: params.whatWasBeingDone.trim() } : {}),
-                ...(params.howToResume?.trim() ? { howToResume: params.howToResume.trim() } : {}),
-                ...(params.extraSections && params.extraSections.length > 0
-                    ? {
-                        extraSections: params.extraSections
-                            .map((section) => ({ heading: section.heading?.trim() ?? "", body: section.body ?? "" }))
-                            .filter((section) => section.heading),
-                    }
-                    : {}),
-            });
-            await st.setPhaseHandoff(resolved.phase.id, markdown);
-            return { content: [{ type: "text", text: `⚠️ plan_write_handoff is deprecated — wrote handoff on ${resolved.compositeRef} (phase.handoff field) instead of .planner/HANDOFF.md. Prefer the handoff_write tool.` }], details: { deprecated: true, phaseRef: resolved.compositeRef, phaseId: resolved.phase.id } };
+            return {
+                content: [{ type: "text", text: `⚠️ plan_write_handoff is deprecated and write-disabled because it bypasses durable context synchronization. Run handoff_prepare for ${resolved.compositeRef}, then call handoff_write with the audit token and entity updates.` }],
+                details: { deprecated: true, writeDisabled: true, phaseRef: resolved.compositeRef, phaseId: resolved.phase.id },
+            };
         },
     });
     pi.registerTool({
@@ -3021,6 +3114,23 @@ export default function planPiExtension(pi) {
         const feat = phase.featureId ? features.find((f) => f.id === phase.featureId) : undefined;
         return { ok: true, phase, compositeRef: formatPhaseRef(phase.number, feat?.number) };
     }
+    async function resolveRequirementPhaseRefs(st, refs) {
+        if (!Array.isArray(refs) || refs.length === 0) {
+            return { ok: false, error: "linkedPhaseIds must contain at least one phase" };
+        }
+        const trimmed = refs.map((entry) => entry.trim()).filter(Boolean);
+        if (trimmed.length === 0) {
+            return { ok: false, error: "linkedPhaseIds must contain non-empty phase references" };
+        }
+        const phases = await st.loadAllPhases();
+        const features = (await st.loadFeatures()).features;
+        const resolved = trimmed.map((ref) => findPhaseByRef(phases, features, ref));
+        const missingIndex = resolved.findIndex((phase) => !phase);
+        if (missingIndex !== -1) {
+            return { ok: false, error: `linked phase not found: ${trimmed[missingIndex]}` };
+        }
+        return { ok: true, linkedPhaseIds: [...new Set(resolved.map((phase) => phase.id))] };
+    }
     pi.registerTool({
         name: "handoff_list",
         label: "Handoff List",
@@ -3055,16 +3165,69 @@ export default function planPiExtension(pi) {
             return { content: [{ type: "text", text: `Handoff for ${r.compositeRef}:\n\n${content}` }], details: { phaseRef: r.compositeRef, phaseId: r.phase.id } };
         },
     });
+    pi.registerTool({
+        name: "handoff_prepare",
+        label: "Handoff Prepare",
+        description: "Audit one exact phase before writing a handoff. Returns the current handoff/version and every done task missing durable completion or verification evidence. Call after the user confirms the target, then reconcile the returned context through handoff_write.",
+        parameters: Type.Object({ phaseRef: Type.String({ description: "Exact confirmed phase ref: P00x | P00x(F00x) | UUID | title." }) }),
+        async execute(_id, params, _signal, _onUpdate, ctx) {
+            const st = await requirePlan(ctx);
+            if (!st)
+                return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
+            const r = await resolvePhaseForHandoff(st, params.phaseRef);
+            if (!r.ok)
+                return { content: [{ type: "text", text: `❌ ${r.error}` }], details: { error: r.error } };
+            try {
+                const audit = await st.preparePhaseHandoff(r.phase.id);
+                const missing = audit.missingCompletionTasks.map((task) => `- T${String(task.number).padStart(3, "0")} — ${task.title}`).join("\n") || "- None";
+                const existing = audit.handoff.trim() || "(none)";
+                return {
+                    content: [{ type: "text", text: [
+                                `Handoff preparation audit for ${r.compositeRef}`,
+                                `Base handoffUpdatedAt: ${audit.handoffUpdatedAt || "(empty)"}`,
+                                "Done tasks missing durable completion/verification evidence:",
+                                missing,
+                                "",
+                                "Existing active handoff (reconcile all still-relevant content):",
+                                existing,
+                            ].join("\n") }],
+                    details: { phaseRef: r.compositeRef, ...audit },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { content: [{ type: "text", text: `❌ Handoff preparation failed: ${message}` }], details: { error: message } };
+            }
+        },
+    });
     pi.registerTool({
         name: "handoff_write",
         label: "Handoff Write",
-        description: "Write/refresh the entity-scoped handoff on a phase. phaseRef is required and must be the exact phase selected with the user. Pass content (or markdown_content) AND a meaningful `title` summarizing the work (e.g. 'P049 — featureId validation: tests + adapter wiring'). Never guess the phase from in-progress status or stale context. Completed/canceled phases reject new handoffs.",
+        description: "Reconcile and refresh the single active phase handoff while synchronizing durable task, phase, and feature context. Run handoff_prepare first and pass its exact handoffUpdatedAt token. Existing context must be reconciled; refreshes do not create superseded archives.",
         parameters: Type.Object({
             phaseRef: Type.String({ description: "Exact confirmed phase ref: P00x | P00x(F00x) | UUID | title." }),
-            title: Type.Optional(Type.String({ description: "Meaningful handoff title summarizing the work (becomes the H1 / first line in lists). REQUIRED if your markdown's first heading is generic. Example: 'P049 — featureId validation: tests + adapter wiring'." })),
+            title: Type.Optional(Type.String({ description: "Meaningful handoff title summarizing the work (becomes the H1 / first line in lists)." })),
             confirmed: Type.Boolean({ description: "Set true only after the user explicitly confirms the proposed feature+phase target." }),
             content: Type.Optional(Type.String({ description: "Handoff text (plain)." })),
             markdown_content: Type.Optional(Type.String({ description: "Handoff text (markdown). Preferred over content." })),
+            expectedHandoffUpdatedAt: Type.Optional(Type.String({ description: "Exact handoffUpdatedAt returned by handoff_prepare; use an empty string when no handoff exists." })),
+            reconciledExistingHandoff: Type.Optional(Type.Boolean({ description: "Confirm that all still-relevant information from the existing handoff was retained in this single refreshed body." })),
+            taskUpdates: Type.Optional(Type.Array(Type.Object({
+                taskRef: Type.String(),
+                completionSummary: Type.String(),
+                verification: Type.String(),
+                remainingWork: Type.String(),
+                filesTouched: Type.Optional(Type.Array(Type.String())),
+                decisions: Type.Optional(Type.Array(Type.String())),
+            }))),
+            phaseUpdate: Type.Optional(Type.Object({
+                progressSummary: Type.String(),
+                remainingWork: Type.String(),
+                decisions: Type.Optional(Type.Array(Type.String())),
+            })),
+            phaseNoUpdateReason: Type.Optional(Type.String({ description: "Required when phaseUpdate is omitted." })),
+            featureUpdate: Type.Optional(Type.Object({ workDone: Type.String(), workRemaining: Type.String() })),
+            featureNoUpdateReason: Type.Optional(Type.String({ description: "Required when featureUpdate is omitted." })),
         }),
         async execute(_id, params, _signal, _onUpdate, ctx) {
             const st = await requirePlan(ctx);
@@ -3074,36 +3237,68 @@ export default function planPiExtension(pi) {
             if (!body)
                 return { content: [{ type: "text", text: "❌ Provide the handoff text (content or markdown_content)." }], details: { error: "empty text" } };
             const title = params.title?.trim();
-            // Derive the current first non-empty line (H1) of the supplied body.
-            const firstLine = body.split(/\r?\n/).find((l) => l.trim().length > 0) ?? "";
+            const firstLine = body.split(/\r?\n/).find((line) => line.trim().length > 0) ?? "";
             const firstHeadingText = firstLine.replace(/^#+\s*/, "").trim();
-            const isGeneric = !firstHeadingText || /^(handoff|canonical handoff|session handoff)$/i.test(firstHeadingText);
-            if (!title && isGeneric) {
-                return {
-                    content: [{ type: "text", text: "❌ Generic handoff title. Provide a meaningful `title` (or start your markdown with a descriptive H1) summarizing the work — e.g. 'P049 — featureId validation: tests + adapter wiring'. Generic titles like 'Handoff' or 'Canonical handoff' are not accepted." }],
-                    details: { error: "generic title", firstHeadingText },
-                };
+            const effectiveHeadingText = title || firstHeadingText;
+            if (!effectiveHeadingText || /^(handoff|canonical handoff|session handoff)$/i.test(effectiveHeadingText)) {
+                return { content: [{ type: "text", text: "❌ Generic handoff title. Provide a meaningful title summarizing the work." }], details: { error: "generic title" } };
             }
-            // Normalize: if a title is provided, replace or prepend the H1 so the first line is the title.
             if (title) {
                 const lines = body.split(/\r?\n/);
-                const firstIdx = lines.findIndex((l) => l.trim().length > 0);
-                if (firstIdx !== -1 && /^#+\s/.test(lines[firstIdx] ?? "")) {
+                const firstIdx = lines.findIndex((line) => line.trim().length > 0);
+                if (firstIdx !== -1 && /^#+\s/.test(lines[firstIdx] ?? ""))
                     lines[firstIdx] = `# ${title}`;
-                    body = lines.join("\n");
-                }
-                else {
-                    body = `# ${title}\n\n${body}`;
-                }
+                else
+                    lines.unshift(`# ${title}`, "");
+                body = lines.join("\n");
             }
             const r = await resolvePhaseForHandoff(st, params.phaseRef);
             if (!r.ok)
                 return { content: [{ type: "text", text: `❌ ${r.error}` }], details: { error: r.error } };
-            if (!params.confirmed) {
-                return { content: [{ type: "text", text: `Proposal only: I would write this handoff on ${r.compositeRef}. Ask the user to confirm this exact feature/phase, then retry with confirmed=true.` }], details: { phaseRef: r.compositeRef, confirmationRequired: true } };
+            if (!params.confirmed)
+                return { content: [{ type: "text", text: `Proposal only: I would refresh this handoff on ${r.compositeRef}. Ask the user to confirm, then run handoff_prepare and retry with confirmed=true.` }], details: { phaseRef: r.compositeRef, confirmationRequired: true } };
+            if (params.expectedHandoffUpdatedAt === undefined)
+                return { content: [{ type: "text", text: "❌ Run handoff_prepare first and pass expectedHandoffUpdatedAt." }], details: { error: "preparation required" } };
+            const phases = await st.loadAllPhases();
+            const features = (await st.loadFeatures()).features;
+            const taskUpdates = [];
+            for (const update of params.taskUpdates ?? []) {
+                const found = findTaskByRef(phases, features, update.taskRef.trim());
+                if (!found || found.phase.id !== r.phase.id)
+                    return { content: [{ type: "text", text: `❌ Task ${update.taskRef} does not belong to ${r.compositeRef}.` }], details: { error: "invalid task update" } };
+                taskUpdates.push({
+                    taskId: found.task.id,
+                    completionSummary: update.completionSummary,
+                    verification: update.verification,
+                    remainingWork: update.remainingWork,
+                    ...(update.filesTouched ? { filesTouched: update.filesTouched } : {}),
+                    ...(update.decisions ? { decisions: update.decisions } : {}),
+                });
+            }
+            try {
+                const result = await st.refreshPhaseHandoff(r.phase.id, {
+                    content: body,
+                    expectedHandoffUpdatedAt: params.expectedHandoffUpdatedAt,
+                    reconciledExistingHandoff: params.reconciledExistingHandoff === true,
+                    contextSync: {
+                        taskUpdates,
+                        ...(params.phaseUpdate ? { phaseUpdate: {
+                                progressSummary: params.phaseUpdate.progressSummary,
+                                remainingWork: params.phaseUpdate.remainingWork,
+                                ...(params.phaseUpdate.decisions ? { decisions: params.phaseUpdate.decisions } : {}),
+                            } } : {}),
+                        ...(params.phaseNoUpdateReason ? { phaseNoUpdateReason: params.phaseNoUpdateReason } : {}),
+                        ...(params.featureUpdate ? { featureUpdate: params.featureUpdate } : {}),
+                        ...(params.featureNoUpdateReason ? { featureNoUpdateReason: params.featureNoUpdateReason } : {}),
+                    },
+                });
+                await st.writeGenerated();
+                return { content: [{ type: "text", text: `✅ Reconciled handoff and durable context on ${r.compositeRef}; updated ${result.updatedTaskIds.length} task(s).` }], details: { phaseRef: r.compositeRef, phaseId: r.phase.id, ...result } };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { content: [{ type: "text", text: `❌ Handoff refresh denied: ${message}` }], details: { error: message } };
             }
-            await st.setPhaseHandoff(r.phase.id, body);
-            return { content: [{ type: "text", text: `✅ Wrote handoff on ${r.compositeRef}.` }], details: { phaseRef: r.compositeRef, phaseId: r.phase.id } };
         },
     });
     pi.registerTool({
@@ -3191,6 +3386,8 @@ export default function planPiExtension(pi) {
             if (!resolvedFeature.ok)
                 return { content: [{ type: "text", text: resolvedFeature.error }], details: {} };
             const feature = resolvedFeature.feature;
+            if (params.full)
+                markFeatureReadForSessionId(plannerSessionId, feature.id);
             const phases = (await st.loadAllPhases()).filter((p) => p.featureId === feature.id);
             const linkedRequirements = await st.linkedRequirementsForFeature(feature.id);
             const summary = `${feature.name} — ${formatFeatureRef(feature.number)}${feature.shortId ? ` · ${feature.shortId}` : ""} (${feature.status}; ${phases.length} phases${linkedRequirements.length ? `; ${linkedRequirements.length} linked requirement${linkedRequirements.length === 1 ? "" : "s"}` : ""})`;
@@ -3239,6 +3436,7 @@ export default function planPiExtension(pi) {
                 phaseIds: [],
                 dependsOn: [],
                 statusLog: [],
+                sessionInfo: [],
                 createdAt: now,
                 updatedAt: now,
             };
@@ -3489,6 +3687,8 @@ export default function planPiExtension(pi) {
             const phase = findPhaseByRef(await st.loadAllPhases(), features, params.phaseId.trim());
             if (!phase)
                 return { content: [{ type: "text", text: `Phase not found: ${params.phaseId}` }], details: {} };
+            if (params.full)
+                markPhaseReadForSessionId(plannerSessionId, phase.id);
             const linkedRequirements = await st.linkedRequirementsForPhase(phase.id);
             const reqCount = linkedRequirements.length;
             const summary = `${phase.title} — ${formatPhaseRef(phase.number, featureNumberOfPhase(phase, features))}${phase.shortId ? ` · ${phase.shortId}` : ""} (${phase.status}; ${phase.tasks.length} tasks${reqCount ? `; ${reqCount} linked requirement${reqCount === 1 ? "" : "s"}` : ""})`;
@@ -3513,6 +3713,9 @@ export default function planPiExtension(pi) {
             const st = await requirePlan(ctx);
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
+            const title = params.title?.trim();
+            if (!title)
+                return { content: [{ type: "text", text: "title required" }], details: {} };
             if (!params.featureId?.trim())
                 return { content: [{ type: "text", text: "featureId is required: a phase must belong to a feature." }], details: {} };
             const createPhaseFeatures = (await st.loadFeatures()).features;
@@ -3533,7 +3736,7 @@ export default function planPiExtension(pi) {
                 const priority = await st.nextPriority("phase", featureId);
                 const now = nowISO();
                 phase = {
-                    id, number: identity.number, shortId: identity.shortId, priority, slug: normalizeSlug(params.title), title: params.title,
+                    id, number: identity.number, shortId: identity.shortId, priority, slug: normalizeSlug(title), title,
                     featureId,
                     status: params.status ?? "draft",
                     discussedAt: "",
@@ -3547,6 +3750,7 @@ export default function planPiExtension(pi) {
                     handoffReadAt: "",
                     handoffHistory: [],
                     statusLog: [],
+                    sessionInfo: [],
                 };
                 await st.savePhase(phase);
                 // Atomic: serialize concurrent phase_create linking to the same feature.
@@ -3823,10 +4027,10 @@ export default function planPiExtension(pi) {
     pi.registerTool({
         name: "task_get",
         label: "Task Get",
-        description: "Show a task. Compact identity by default (saves tokens); pass full=true to include the description + statusLog.",
+        description: "Show a task. Compact identity by default (saves tokens); pass full=true to include the description, resume checkpoint/advisory, and statusLog.",
         parameters: Type.Object({
             taskId: Type.String({ description: "Task ref: F00x/P00x/T00x, bare T00x (global), 5-char shortId, UUID, or title" }),
-            full: Type.Optional(Type.Boolean({ description: "If true, include the task description + statusLog. Default: compact identity only." })),
+            full: Type.Optional(Type.Boolean({ description: "If true, include the task description, resume checkpoint/advisory, and statusLog. Default: compact identity only." })),
         }),
         async execute(_id, params, _signal, _onUpdate, ctx) {
             const st = await requirePlan(ctx);
@@ -3836,11 +4040,37 @@ export default function planPiExtension(pi) {
             const found = findTaskByRef(await st.loadAllPhases(), features, params.taskId.trim());
             if (!found)
                 return { content: [{ type: "text", text: `Task not found: ${params.taskId}` }], details: {} };
+            if (params.full)
+                markTaskReadForSessionId(plannerSessionId, found.task.id);
             const summary = `${found.task.title} — ${formatPhaseRef(found.phase.number, featureNumberOfPhase(found.phase, features))}/T${pad(found.task.number)}${found.task.shortId ? ` · ${found.task.shortId}` : ""} (${found.task.status})`;
             if (!params.full)
                 return { content: [{ type: "text", text: summary }], details: {} };
+            const project = await st.loadProject();
+            const pendingDeviation = found.task.status === "done" || found.task.status === "canceled" || found.task.status === "rejected"
+                ? undefined
+                : project.workDeviations
+                    .filter((deviation) => deviation.resumeTaskId === found.task.id
+                    && (deviation.state === "resume-required" || deviation.state === "resolved"))
+                    .sort((left, right) => right.createdAt.localeCompare(left.createdAt))[0];
+            const snapshot = found.task.pauseSnapshot ?? pendingDeviation?.snapshot ?? null;
             const log = (found.task.statusLog ?? []).map((e) => `  - ${e.date.slice(0, 10)} ${e.title}`).join("\n");
-            return { content: [{ type: "text", text: `${summary}\n\n${found.task.description || ""}${log ? `\n\nStatus log:\n${log}` : ""}` }], details: {} };
+            const sections = [summary];
+            if (found.task.description?.trim())
+                sections.push(found.task.description.trim());
+            if (snapshot || pendingDeviation) {
+                sections.push([
+                    pendingDeviation
+                        ? "Resume advisory: this task has a saved checkpoint that should be evaluated before selecting other work."
+                        : "Resume checkpoint:",
+                    snapshot ? `Checkpoint reason: ${snapshot.reason}` : "",
+                    snapshot ? `Work checkpoint: ${snapshot.whatWasBeingDone}` : "",
+                    snapshot ? `Resume from: ${snapshot.resumeLocation}` : "",
+                    snapshot ? `How to resume: ${snapshot.howToResume}` : "",
+                ].filter(Boolean).join("\n"));
+            }
+            if (log)
+                sections.push(`Status log:\n${log}`);
+            return { content: [{ type: "text", text: sections.join("\n\n") }], details: {} };
         },
     });
     pi.registerTool({
@@ -3860,6 +4090,9 @@ export default function planPiExtension(pi) {
             const st = await requirePlan(ctx);
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
+            const title = params.title?.trim();
+            if (!title)
+                return { content: [{ type: "text", text: "title required" }], details: {} };
             if (!params.featureId?.trim())
                 return { content: [{ type: "text", text: "featureId is required: a task must belong to a feature." }], details: {} };
             const features = (await st.loadFeatures()).features;
@@ -3886,23 +4119,24 @@ export default function planPiExtension(pi) {
             const existingPhase = await st.loadPhase(phaseId);
             if (!existingPhase)
                 return { content: [{ type: "text", text: `Resolved phase ${phaseId} no longer exists. Refusing to create task.` }], details: {} };
-            const shortName = clampSlug(params.shortName ?? params.title, 30, `task-${Date.now().toString(36)}`); // clamp+strip trailing dash; never empty
+            const initialStatus = params.status ?? "planned";
+            if (initialStatus !== "planned") {
+                return { content: [{ type: "text", text: "Tasks must be created planned. Use task_start for in-progress work and task_update for other justified status changes." }], details: {} };
+            }
+            const shortName = clampSlug(params.shortName ?? title, 30, `task-${Date.now().toString(36)}`); // clamp+strip trailing dash; never empty
             const taskId = createTaskId();
             const identity = await st.allocateEntityIdentity("task", taskId);
             const priority = await st.nextPriority("task", phaseId);
             const now = nowISO();
-            const initialStatus = params.status ?? "planned";
-            if (initialStatus === "paused") {
-                return { content: [{ type: "text", text: "A task cannot be created paused without an in-progress checkpoint. Create it planned, then use task_pause/task_switch." }], details: {} };
-            }
             const task = {
                 id: taskId, phaseId, number: identity.number, shortId: identity.shortId, priority, shortName,
-                title: params.title,
+                title,
                 status: initialStatus,
                 description: params.description ?? "",
                 descriptionUpdatedAt: now,
                 notes: "",
                 statusLog: [],
+                sessionInfo: [],
                 decisions: [],
                 acceptedDecisions: [],
                 checklist: params.checklist
@@ -3912,8 +4146,8 @@ export default function planPiExtension(pi) {
                 dependsOn: [],
                 pauseSnapshot: null,
                 pauseHistory: [],
-                startedAt: initialStatus === "in-progress" || initialStatus === "done" ? now : "",
-                completedAt: initialStatus === "done" ? now : "",
+                startedAt: "",
+                completedAt: "",
                 createdAt: now, updatedAt: now,
             };
             // Atomic read-modify-write on the phase file: serializes concurrent
@@ -3967,6 +4201,18 @@ export default function planPiExtension(pi) {
             // Validate the motivation requirement for restrictive status transitions,
             // mirroring the MCP adapter and the /planner task update command
             // (AGENTS.md rule 8 — rejected writes must leave the files unchanged).
+            if (params.status === "in-progress" && params.status !== found.task.status) {
+                return {
+                    content: [{ type: "text", text: "Task start/resume transitions require task_start so lifecycle state, checkpoints, and return stacks remain consistent." }],
+                    details: {},
+                };
+            }
+            if (params.status === "done" && params.status !== found.task.status) {
+                return {
+                    content: [{ type: "text", text: "Task completion transitions require task_complete with durable completion and verification evidence." }],
+                    details: {},
+                };
+            }
             if (params.status !== undefined &&
                 params.status !== found.task.status &&
                 needsMotivation(found.task.status, params.status)) {
@@ -4061,14 +4307,14 @@ export default function planPiExtension(pi) {
     pi.registerTool({
         name: "task_recommend",
         label: "Task Recommend",
-        description: "Return the recommended next task without starting work: continue one active task, otherwise choose ready work by feature → phase → task priority. Reports approved deviation/resume context and never blocks an explicit user choice.",
+        description: "Return the recommended next task without starting work: continue one active task or the current phase, otherwise choose ready work by feature → phase → task priority. Reports approved deviation/resume context and never blocks an explicit user choice.",
         parameters: Type.Object({}),
         async execute(_id, _params, _signal, _onUpdate, ctx) {
             const st = await requirePlan(ctx);
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
-            const [features, phases, project] = await Promise.all([st.loadFeatures(), st.loadAllPhases(), st.loadProject()]);
-            const result = recommendNextTask(features.features, phases, project.workDeviations);
+            const [features, phases, project, resume] = await Promise.all([st.loadFeatures(), st.loadAllPhases(), st.loadProject(), st.loadResume()]);
+            const result = recommendNextTask(features.features, phases, project.workDeviations, resume?.currentPhaseId);
             if (!result.candidate)
                 return { content: [{ type: "text", text: `No task recommendation: ${result.reason}` }], details: result };
             const { candidate } = result;
@@ -4092,11 +4338,11 @@ export default function planPiExtension(pi) {
             const st = await requirePlan(ctx);
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
-            const [features, phases, project] = await Promise.all([st.loadFeatures(), st.loadAllPhases(), st.loadProject()]);
+            const [features, phases, project, focus] = await Promise.all([st.loadFeatures(), st.loadAllPhases(), st.loadProject(), st.loadResume()]);
             const temporary = findTaskByRef(phases, features.features, params.temporary_task.trim());
             if (!temporary)
                 return { content: [{ type: "text", text: `Task not found: ${params.temporary_task}` }], details: {} };
-            const selected = recommendNextTask(features.features, phases, project.workDeviations);
+            const selected = recommendNextTask(features.features, phases, project.workDeviations, focus?.currentPhaseId);
             const resume = params.resume_task ? findTaskByRef(phases, features.features, params.resume_task.trim()) : selected.candidate;
             if (!resume)
                 return { content: [{ type: "text", text: `No resume task is available. Provide resume_task explicitly. ${selected.reason}` }], details: selected };
@@ -4145,7 +4391,8 @@ export default function planPiExtension(pi) {
                 resumeLocation: params.resume_location.trim(), howToResume: params.how_to_resume.trim(), relatedTaskId: "",
                 pausedAt: nowISO(), pausedBy: params.paused_by?.trim() ?? "",
             };
-            const paused = await st.pauseTask(found.phase.id, found.task.id, snapshot);
+            invalidateReads();
+            const checkpointed = await st.pauseTask(found.phase.id, found.task.id, snapshot);
             await st.syncTaskStatusRollup(found.phase.id);
             const activeDeviation = (await st.loadProject()).workDeviations
                 .filter((deviation) => (deviation.state === "approved" || deviation.state === "active")
@@ -4157,27 +4404,27 @@ export default function planPiExtension(pi) {
                 ? findTaskByRef(await st.loadAllPhases(), features, activeDeviation.resumeTaskId)
                 : undefined;
             await st.writeGenerated();
-            const reference = `${formatPhaseRef(found.phase.number, featureNumberOfPhase(found.phase, features))}/T${String(paused.number).padStart(3, "0")}`;
+            const reference = `${formatPhaseRef(found.phase.number, featureNumberOfPhase(found.phase, features))}/T${String(checkpointed.number).padStart(3, "0")}`;
             const resumeRef = resume
                 ? `${formatPhaseRef(resume.phase.number, featureNumberOfPhase(resume.phase, features))}/T${String(resume.task.number).padStart(3, "0")}`
                 : "";
             return {
                 content: [{ type: "text", text: [
-                            `⏸️ Task paused: ${reference} — ${paused.title}`,
+                            `💾 Resume checkpoint saved: ${reference} — ${checkpointed.title}`,
                             `Why: ${snapshot.reason}`,
                             `Checkpoint: ${snapshot.whatWasBeingDone}`,
                             `Resume from: ${snapshot.resumeLocation}`,
                             `How to resume: ${snapshot.howToResume}`,
                             resume ? `↩️ RESUME REQUIRED: ${resumeRef} — ${resume.task.title}` : "",
                         ].filter(Boolean).join("\n") }],
-                details: { task: paused, snapshot, ...(resume ? { resumeRequired: { taskId: resume.task.id } } : {}) },
+                details: { task: checkpointed, snapshot, ...(resume ? { resumeRequired: { taskId: resume.task.id } } : {}) },
             };
         },
     });
     pi.registerTool({
         name: "task_switch",
         label: "Task Switch",
-        description: "Switch from active work to a temporary task, even outside priority order. Atomically snapshots/pauses the source, starts the target, and pushes a durable LIFO return target.",
+        description: "Switch from active work to a temporary task, even outside priority order. Reuse the target's valid sessionInfo context or require the exact full tree when missing or stale. Atomically snapshot/pause the source, start the target, and push a durable LIFO return target.",
         parameters: Type.Object({
             from_task: Type.String({ description: "Currently in-progress task ref" }),
             to_task: Type.String({ description: "Temporary task ref to start" }),
@@ -4191,7 +4438,7 @@ export default function planPiExtension(pi) {
             const st = await requirePlan(ctx);
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
-            const [featuresDoc, phases, project] = await Promise.all([st.loadFeatures(), st.loadAllPhases(), st.loadProject()]);
+            const [featuresDoc, phases, project, focus] = await Promise.all([st.loadFeatures(), st.loadAllPhases(), st.loadProject(), st.loadResume()]);
             const features = featuresDoc.features;
             const source = findTaskByRef(phases, features, params.from_task.trim());
             const target = findTaskByRef(phases, features, params.to_task.trim());
@@ -4201,8 +4448,35 @@ export default function planPiExtension(pi) {
                 return { content: [{ type: "text", text: `Task not found: ${params.to_task}` }], details: {} };
             if (source.task.id === target.task.id)
                 return { content: [{ type: "text", text: "Source and temporary task must differ." }], details: {} };
-            if (source.task.status !== "in-progress" && source.task.status !== "paused") {
-                return { content: [{ type: "text", text: `Task switch denied: source is ${source.task.status}; only in-progress or pending-resume paused work can be switched.` }], details: {} };
+            if (source.task.status !== "in-progress" && !source.task.pauseSnapshot) {
+                return { content: [{ type: "text", text: `Task switch denied: source is ${source.task.status}; only in-progress or checkpointed work can be switched.` }], details: {} };
+            }
+            const targetFeature = target.phase.featureId ? features.find((feature) => feature.id === target.phase.featureId) : undefined;
+            const linkedRequirements = [
+                ...(await st.linkedRequirementsForPhase(target.phase.id)),
+                ...(target.phase.featureId ? await st.linkedRequirementsForFeature(target.phase.featureId) : []),
+            ].filter((requirement, index, all) => all.findIndex((candidate) => candidate.id === requirement.id) === index);
+            const linkedRequirementIds = linkedRequirements.map((requirement) => requirement.id);
+            const contextInput = {
+                sessionId: plannerSessionId,
+                taskId: target.task.id,
+                phaseId: target.phase.id,
+                ...(target.phase.featureId ? { featureId: target.phase.featureId } : {}),
+                task: target.task,
+                phase: target.phase,
+                ...(targetFeature ? { feature: targetFeature } : {}),
+                requirements: linkedRequirements,
+                requirementIds: linkedRequirementIds,
+            };
+            const contextEligibility = contextReadEligibilityForSession(contextInput);
+            if (!contextEligibility.eligible) {
+                return { content: [{ type: "text", text: `Task switch denied: context reads required. ${contextEligibility.reason}` }], details: contextEligibility };
+            }
+            if (!hasReadRequirementsForSession(plannerSessionId, linkedRequirementIds, linkedRequirements)) {
+                return { content: [{ type: "text", text: "Task switch denied: read the requirements linked to the target phase and feature before switching." }], details: { requirementIds: linkedRequirementIds } };
+            }
+            if (!hasValidSessionAttestation(contextInput)) {
+                await st.recordContextRead({ sessionId: plannerSessionId, phaseId: target.phase.id, taskId: target.task.id, ...(target.phase.featureId ? { featureId: target.phase.featureId } : {}), requirementIds: linkedRequirementIds });
             }
             const eligibility = checkExplicitTaskStart(features, phases, target.task.id, project.workDeviations);
             if (!eligibility.eligible)
@@ -4213,7 +4487,7 @@ export default function planPiExtension(pi) {
                 resumeLocation: params.resume_location.trim(), howToResume: params.how_to_resume.trim(),
                 relatedTaskId: target.task.id, pausedAt: timestamp, pausedBy: params.switched_by?.trim() ?? "",
             };
-            const selection = recommendNextTask(features, phases, project.workDeviations);
+            const selection = recommendNextTask(features, phases, project.workDeviations, focus?.currentPhaseId);
             const record = {
                 id: crypto.randomUUID(), recommendedTaskId: selection.candidate?.task.id ?? source.task.id,
                 temporaryTaskId: target.task.id, resumeTaskId: source.task.id, reason: snapshot.reason, snapshot,
@@ -4232,7 +4506,7 @@ export default function planPiExtension(pi) {
                     await st.updatePhase(source.phase.id, (phase) => {
                         const task = phase.tasks.find((entry) => entry.id === source.task.id);
                         if (!task)
-                            throw new Error(`Paused source task disappeared: ${params.from_task}`);
+                            throw new Error(`Checkpointed source task disappeared: ${params.from_task}`);
                         task.pauseSnapshot = snapshot;
                         task.pauseHistory = [...task.pauseHistory, snapshot];
                         task.updatedAt = timestamp;
@@ -4240,7 +4514,7 @@ export default function planPiExtension(pi) {
                     });
                 }
                 sourceCheckpointed = true;
-                if (target.task.status === "paused") {
+                if (target.task.pauseSnapshot) {
                     await st.resumeTask(target.phase.id, target.task.id, timestamp);
                 }
                 else {
@@ -4262,7 +4536,7 @@ export default function planPiExtension(pi) {
                 }
                 targetStarted = true;
                 await st.addWorkDeviation(record);
-                if (target.task.status === "paused") {
+                if (target.task.pauseSnapshot) {
                     const resumedDeviation = project.workDeviations
                         .filter((deviation) => deviation.resumeTaskId === target.task.id
                         && (deviation.state === "resume-required" || deviation.state === "resolved"))
@@ -4293,12 +4567,13 @@ export default function planPiExtension(pi) {
             if (target.phase.id !== source.phase.id)
                 await st.syncTaskStatusRollup(target.phase.id);
             await st.writeGenerated();
+            invalidateReads();
             const sourceRef = `${formatPhaseRef(source.phase.number, featureNumberOfPhase(source.phase, features))}/T${String(source.task.number).padStart(3, "0")}`;
             const targetRef = `${formatPhaseRef(target.phase.number, featureNumberOfPhase(target.phase, features))}/T${String(target.task.number).padStart(3, "0")}`;
             return {
                 content: [{ type: "text", text: [
                             `🔀 Task switched: ${sourceRef} → ${targetRef}`,
-                            `Paused snapshot: ${snapshot.whatWasBeingDone}`,
+                            `Resume checkpoint: ${snapshot.whatWasBeingDone}`,
                             `Return target: ${sourceRef} from ${snapshot.resumeLocation}`,
                             "Normal priority was deliberately overridden; completing the temporary task will emit RESUME REQUIRED.",
                         ].join("\n") }],
@@ -4309,39 +4584,100 @@ export default function planPiExtension(pi) {
     pi.registerTool({
         name: "task_start",
         label: "Task Start",
-        description: "Set a task to in-progress or resume paused work. BEFORE calling, read feature_get(full=true), phase_get(full=true), then task_get(full=true). A different active task must first be suspended through task_switch. Otherwise follow active/pending-resume/feature → phase → task priority guidance.",
+        description: "Set a task to in-progress or resume checkpointed work. Read the exact full task → phase → feature tree and linked requirements once per harness session; subsequent starts reuse persisted sessionInfo while entity updatedAt values remain unchanged. A stale or denied start is an isError result with started=false and an exact retry sequence; NEVER claim work started unless details.started is true. Success is returned only after persisted in-progress state is verified.",
         parameters: Type.Object({
             taskId: Type.String({ description: "Task ref: F00x/P00x/T00x, bare T00x (global), 5-char shortId, UUID, or title to start" }),
         }),
         async execute(_id, params, _signal, _onUpdate, ctx) {
             const st = await requirePlan(ctx);
             if (!st)
-                return { content: [{ type: "text", text: "No .planner/ found." }], details: {} };
+                return taskStartFailure(taskStartDenied("PLAN_NOT_FOUND", "No .planner/ found.", ["Initialize or load the planner, then retry task_start."]));
             const features = (await st.loadFeatures()).features;
             const found = findTaskByRef(await st.loadAllPhases(), features, params.taskId.trim());
             if (!found)
-                return { content: [{ type: "text", text: `Task not found: ${params.taskId}` }], details: {} };
+                return taskStartFailure(taskStartDenied("TASK_NOT_FOUND", `Task not found: ${params.taskId}`, ["Resolve the task with task_list or task_get, then retry task_start."]));
             const task = found.task;
-            if (task.status === "in-progress")
-                return { content: [{ type: "text", text: `Task ${task.id} is already in-progress.` }], details: task };
+            const phaseRef = formatPhaseRef(found.phase.number, featureNumberOfPhase(found.phase, features));
+            const taskRef = `${phaseRef}/T${String(task.number).padStart(3, "0")}`;
+            const feature = found.phase.featureId ? features.find((candidate) => candidate.id === found.phase.featureId) : undefined;
+            const featureRef = feature ? formatFeatureRef(feature.number) : "";
+            if (task.status === "in-progress") {
+                const outcome = taskStartSucceeded(task.id, true);
+                return { content: [{ type: "text", text: `✅ Task already started: ${taskRef} — ${task.title} (in-progress)\nstarted: true` }], details: { ...task, ...outcome, task } };
+            }
             if (task.status === "done")
-                return { content: [{ type: "text", text: `Task ${task.id} is done. Use task_update to reopen.` }], details: task };
-            const project = await st.loadProject();
-            const phases = await st.loadAllPhases();
+                return taskStartFailure(taskStartDenied("TASK_DONE", `Task ${taskRef} is done and was not reopened.`, [`Use task_update with status=planned and a motivation to reopen ${taskRef}.`, `Repeat the required full context reads, then retry task_start ${taskRef}.`], { taskId: task.id }));
+            const linkedRequirements = [
+                ...(await st.linkedRequirementsForPhase(found.phase.id)),
+                ...(found.phase.featureId ? await st.linkedRequirementsForFeature(found.phase.featureId) : []),
+            ].filter((requirement, index, all) => all.findIndex((candidate) => candidate.id === requirement.id) === index);
+            const linkedRequirementIds = linkedRequirements.map((requirement) => requirement.id);
+            const contextInput = {
+                sessionId: plannerSessionId,
+                taskId: task.id,
+                phaseId: found.phase.id,
+                ...(found.phase.featureId ? { featureId: found.phase.featureId } : {}),
+                task,
+                phase: found.phase,
+                ...(feature ? { feature } : {}),
+                requirements: linkedRequirements,
+                requirementIds: linkedRequirementIds,
+            };
+            const contextEligibility = contextReadEligibilityForSession(contextInput);
+            if (!contextEligibility.eligible) {
+                return taskStartFailure(taskStartDenied("CONTEXT_READ_REQUIRED", `Required context reads are incomplete or stale. ${contextEligibility.reason}`, [
+                    `task_get ${taskRef} with full=true`,
+                    `phase_get ${phaseRef} with full=true`,
+                    ...(featureRef ? [`feature_get ${featureRef} with full=true`] : []),
+                    ...(linkedRequirementIds.length > 0 ? ["requirement_list"] : []),
+                    `Retry task_start ${taskRef}`,
+                ], { taskId: task.id }), { contextEligibility });
+            }
+            if (!hasReadRequirementsForSession(plannerSessionId, linkedRequirementIds, linkedRequirements)) {
+                return taskStartFailure(taskStartDenied("REQUIREMENTS_READ_REQUIRED", "Linked requirements were not read; the task remains unchanged.", ["requirement_list", `Retry task_start ${taskRef}`], { taskId: task.id, requirementIds: linkedRequirementIds }));
+            }
+            if (!hasValidSessionAttestation(contextInput)) {
+                await st.recordContextRead({
+                    sessionId: plannerSessionId,
+                    phaseId: found.phase.id,
+                    taskId: task.id,
+                    ...(found.phase.featureId ? { featureId: found.phase.featureId } : {}),
+                    requirementIds: linkedRequirementIds,
+                });
+            }
+            const [project, phases, focus] = await Promise.all([st.loadProject(), st.loadAllPhases(), st.loadResume()]);
             const eligibility = checkExplicitTaskStart(features, phases, task.id, project.workDeviations);
             if (!eligibility.eligible)
-                return { content: [{ type: "text", text: `Task start denied: ${eligibility.reason}` }], details: eligibility };
-            const selection = recommendNextTask(features, phases, project.workDeviations);
+                return taskStartFailure(taskStartDenied("START_NOT_ALLOWED", eligibility.reason, ["Resolve the reported task readiness condition, then retry task_start."], { taskId: task.id }), { eligibility });
+            const selection = recommendNextTask(features, phases, project.workDeviations, focus?.currentPhaseId);
             if (selection.kind === "conflict") {
-                return { content: [{ type: "text", text: `${selection.reason} Pause/reconcile active tasks before starting another task.` }], details: selection };
+                return taskStartFailure(taskStartDenied("ACTIVE_TASK_CONFLICT", selection.reason, ["Pause or reconcile the active tasks.", `Retry task_start ${taskRef}.`], { taskId: task.id }), { selection });
             }
             if (selection.kind === "active" && selection.candidate?.task.id !== task.id) {
                 const activeRef = `${formatPhaseRef(selection.candidate.phase.number, featureNumberOfPhase(selection.candidate.phase, features))}/T${String(selection.candidate.task.number).padStart(3, "0")}`;
-                return { content: [{ type: "text", text: `Task start denied: ${activeRef} is active. Use task_switch to snapshot and pause it before starting another task.` }], details: selection };
+                return taskStartFailure(taskStartDenied("ACTIVE_TASK_CONFLICT", `${activeRef} is active; ${taskRef} was not started.`, [`Use task_switch to snapshot and pause ${activeRef}.`, `Retry task_start ${taskRef}.`], { taskId: task.id }), { selection });
             }
-            if (selection.kind === "resume" && selection.candidate?.task.id !== task.id) {
-                const resumeRef = `${formatPhaseRef(selection.candidate.phase.number, featureNumberOfPhase(selection.candidate.phase, features))}/T${String(selection.candidate.task.number).padStart(3, "0")}`;
-                return { content: [{ type: "text", text: `Task start denied: ${resumeRef} is pending resume. Resume it now, or use task_switch from that paused task with a new checkpoint and reason.` }], details: selection };
+            let resumeProposal;
+            if (selection.kind === "resume" && selection.candidate && selection.candidate.task.id !== task.id) {
+                // Advisory only: a pending resume must be surfaced loudly, but it must
+                // not hard-block an explicit start of a different task. Capture a
+                // structured proposal so the resume-first guidance is explicit and
+                // machine-readable for the host/agent.
+                const resumeTask = selection.candidate;
+                const resumeRef = `${formatPhaseRef(resumeTask.phase.number, featureNumberOfPhase(resumeTask.phase, features))}/T${String(resumeTask.task.number).padStart(3, "0")}`;
+                const resumeSnapshot = resumeTask.task.pauseSnapshot
+                    ?? project.workDeviations.find((deviation) => deviation.resumeTaskId === resumeTask.task.id
+                        && (deviation.state === "resume-required" || deviation.state === "resolved"))?.snapshot
+                    ?? null;
+                resumeProposal = buildResumeRequiredProposal({
+                    ref: resumeRef,
+                    title: resumeTask.task.title,
+                    taskId: resumeTask.task.id,
+                    phaseId: resumeTask.phase.id,
+                    snapshot: resumeSnapshot
+                        ? { reason: resumeSnapshot.reason, resumeLocation: resumeSnapshot.resumeLocation, howToResume: resumeSnapshot.howToResume }
+                        : null,
+                });
             }
             // Assemble the mandatory parent context before changing task lifecycle state.
             // The output order is feature + its requirements, then phase + its requirements.
@@ -4352,11 +4688,13 @@ export default function planPiExtension(pi) {
             ]);
             const phaseContext = buildPhaseContextBlock(phaseWithRequirements, parentFeature, phaseWithRequirements.linkedRequirements ?? [], featureRequirements);
             const advisory = selection.candidate && selection.candidate.task.id !== task.id
-                ? `\n\n⚠️ ${selection.kind === "resume" ? "Resume" : "Priority"} advisory: ${formatPhaseRef(selection.candidate.phase.number, featureNumberOfPhase(selection.candidate.phase, features))}/T${String(selection.candidate.task.number).padStart(3, "0")} is the automatic recommendation. Explicit task request honored.`
+                ? selection.kind === "resume"
+                    ? `\n\n${resumeProposal ? resumeProposal.text : `⚠️ Resume advisory: ${formatPhaseRef(selection.candidate.phase.number, featureNumberOfPhase(selection.candidate.phase, features))}/T${String(selection.candidate.task.number).padStart(3, "0")} has a saved checkpoint. Evaluate its resume context before continuing with this explicit task request. Explicit task request honored.`}`
+                    : `\n\n⚠️ Priority advisory: ${formatPhaseRef(selection.candidate.phase.number, featureNumberOfPhase(selection.candidate.phase, features))}/T${String(selection.candidate.task.number).padStart(3, "0")} is the automatic recommendation. Explicit task request honored.`
                 : "";
             const now = nowISO();
             let startedTask;
-            if (task.status === "paused") {
+            if (task.pauseSnapshot) {
                 startedTask = await st.resumeTask(found.phase.id, found.task.id, now);
             }
             else {
@@ -4388,19 +4726,26 @@ export default function planPiExtension(pi) {
             if (resumedDeviation)
                 await st.setWorkDeviationState(resumedDeviation.id, "resumed", now);
             await st.writeGenerated();
-            if (!startedTask)
-                return { content: [{ type: "text", text: `Task not found: ${params.taskId}` }], details: {} };
-            return { content: [{ type: "text", text: `✅ Task started: ${formatPhaseRef(found.phase.number, featureNumberOfPhase(found.phase, features))}/T${String(startedTask.number).padStart(3, "0")} — ${startedTask.title} (in-progress)${startedTask.shortId ? ` · ${startedTask.shortId}` : ""}${phaseContext}${advisory}` }], details: startedTask };
+            const persistedTask = (await st.loadPhase(found.phase.id)).tasks.find((candidate) => candidate.id === task.id);
+            if (!startedTask || persistedTask?.status !== "in-progress") {
+                return taskStartFailure(taskStartDenied("PERSISTENCE_VERIFICATION_FAILED", `The lifecycle write could not be verified as in-progress for ${taskRef}.`, ["Inspect task_get for the persisted state and retry task_start only after resolving the persistence failure."], { taskId: task.id }));
+            }
+            const outcome = taskStartSucceeded(persistedTask.id);
+            return {
+                content: [{ type: "text", text: `✅ Task started: ${taskRef} — ${persistedTask.title} (in-progress)${persistedTask.shortId ? ` · ${persistedTask.shortId}` : ""}\nstarted: true${phaseContext}${advisory}` }],
+                details: { ...persistedTask, ...outcome, task: persistedTask },
+                ...(resumeProposal ? { resumeRequired: resumeProposal.structured } : {}),
+            };
         },
     });
     pi.registerTool({
         name: "task_complete",
         label: "Task Complete",
-        description: "Mark a task as done. Sets completedAt and startedAt (if missing) automatically. Checks for unchecked checklist items and warns unless force=true.",
+        description: "Mark a task as done with mandatory durable completion and verification evidence. Sets completedAt and startedAt (if missing) automatically. Checks for unchecked checklist items and warns unless force=true.",
         parameters: Type.Object({
             taskId: Type.String({ description: "Task ref: F00x/P00x/T00x, bare T00x (global), 5-char shortId, UUID, or title to complete" }),
             force: Type.Optional(Type.Boolean({ description: "Skip checklist completion check. Default: false" })),
-            description_update: Type.Optional(Type.String({ description: "Post-hoc summary: commit hash(s), files touched, decisions made, updated code references with new line numbers. Keeps the planner alive and traceable." })),
+            description_update: Type.String({ minLength: 10, description: "Required evidence: shipped work, verification level including partial verification, remaining/unverified work, files, decisions, and updated code references." }),
         }),
         async execute(_id, params, _signal, _onUpdate, ctx) {
             const st = await requirePlan(ctx);
@@ -4413,8 +4758,11 @@ export default function planPiExtension(pi) {
             const task = found.task;
             if (task.status === "done")
                 return { content: [{ type: "text", text: `Task ${task.id} is already done.` }], details: task };
-            if (task.status === "paused")
-                return { content: [{ type: "text", text: "Task completion denied: resume paused work with task_start before completing it, or cancel it explicitly with motivation." }], details: task };
+            const completionSummary = params.description_update?.trim() ?? "";
+            if (completionSummary.length < 10)
+                return { content: [{ type: "text", text: "Task completion denied: provide at least 10 characters of durable completion and verification evidence." }], details: { error: "completion evidence required" } };
+            if (task.pauseSnapshot)
+                return { content: [{ type: "text", text: "Task completion denied: resume checkpointed work with task_start before completing it, or cancel it explicitly with motivation." }], details: task };
             const unchecked = task.checklist.filter((item) => !item.checked);
             if (unchecked.length > 0 && !params.force) {
                 return {
@@ -4433,12 +4781,11 @@ export default function planPiExtension(pi) {
                 t.statusLog = [...t.statusLog, {
                         id: createChecklistItemId(t.id, t.statusLog.length + 1, `${previousStatus}-done`),
                         date: now, fromStatus: previousStatus, toStatus: "done",
-                        title: `${previousStatus} → done`, description: "",
+                        title: `${previousStatus} → done`, description: completionSummary,
                     }];
-                if (params.description_update) {
-                    const sep = t.description ? "\n\n---\n**Completion summary:**\n" : "**Completion summary:**\n";
-                    t.description = t.description + sep + params.description_update;
-                }
+                const sep = t.description ? "\n\n---\n**Completion summary:**\n" : "**Completion summary:**\n";
+                t.description = t.description + sep + completionSummary;
+                t.descriptionUpdatedAt = now;
                 t.updatedAt = now;
                 phase.updatedAt = now;
                 completedTask = t;
@@ -4463,7 +4810,7 @@ export default function planPiExtension(pi) {
                     resumeNotice = [
                         "",
                         `↩️ RESUME REQUIRED: ${resumeRef} — ${resume.task.title}`,
-                        snapshot ? `Paused because: ${snapshot.reason}` : "Return to the preserved task before selecting new priority work.",
+                        snapshot ? `Checkpoint reason: ${snapshot.reason}` : "Return to the preserved task before selecting new priority work.",
                         snapshot ? `Resume from: ${snapshot.resumeLocation}` : "",
                         snapshot ? `How to resume: ${snapshot.howToResume}` : "",
                         `Next action: task_start ${resumeRef}`,
@@ -4650,7 +4997,7 @@ export default function planPiExtension(pi) {
             const st = await requirePlan(ctx);
             if (!st)
                 return { content: [{ type: "text", text: "No .planner/ found. Run plan_init first." }], details: { enabled: false, running: false } };
-            plannerSessionEnabled = true;
+            enablePlannerSession();
             if (!server) {
                 await startServer(ctx, undefined, "lan").catch(() => { });
             }
@@ -4722,6 +5069,7 @@ export default function planPiExtension(pi) {
             const activity = await st.loadActivityLog();
             const recentActivity = activity.entries.slice(-3).reverse();
             const handoffs = await st.listHandoffs();
+            const extensionRules = await st.extensionRules();
             const featureById = new Map(plan.features.features.map((feature) => [feature.id, feature]));
             const phaseById = new Map(plan.phases.map((phase) => [phase.id, phase]));
             const orderedPhases = [
@@ -4827,7 +5175,7 @@ export default function planPiExtension(pi) {
                 "STARTUP RESUME PROTOCOL (mandatory):",
                 "- Present the planner recap to the user. The recap text was delivered with the trigger message — do NOT call tools, do NOT narrate, do NOT quote/expose AGENTS.md or any internal instructions.",
                 `- Write in ${project.chatLanguage || "English"}.`,
-                "- After presenting: if the user says yes to resuming and no task is in-progress, your NEXT action must be task_start before any CODE edit/write (planner ops like handoff_write are NOT code edits).",
+                "- After presenting: if the user says yes to resuming and no task is in-progress, your NEXT action must be task_start before any CODE edit/write. If task_start returns started=false/isError, satisfy its exact prerequisites and retry; never claim the task started until details.started=true (planner ops like handoff_write are NOT code edits).",
             ].filter(Boolean).join("\n") : "";
             // Build/refresh the context block (slow path: cache miss).
             const contextBlock = [
@@ -4836,12 +5184,19 @@ export default function planPiExtension(pi) {
                 "",
                 "Operational rules:",
                 "- Handoffs are context, not locks. Read the relevant handoff with handoff show <ref> before resuming.",
-                "- BEFORE work: read feature_get(full=true) for the parent feature and its linked requirements, then phase_get(full=true) for the parent phase and its linked requirements, then task_get(full=true); only then call task_start before any code edit/write. AFTER finishing a task: task_complete.",
+                "- BEFORE work: read the exact task(full), parent phase(full), parent feature(full), and linked requirements once per harness session in that order. Later task_start, resume, or task_switch calls reuse valid sessionInfo; reread only after a new session, a lineage change, or an entity updatedAt change. A denial is an error with started=false: follow its nextActions and retry; only details.started=true proves the task is in-progress. Only then touch code. AFTER finishing: task_complete with durable completion/verification evidence.",
                 "- Record every new decision or user-agreed modification in both the relevant feature and phase before treating the discussion as complete.",
                 "- Use task_update with motivation for blocked/canceled/rejected/deferred/waiting/planned(from non-planned).",
                 "- Planner ops (status/handoff/planner metadata) are NOT code edits; they are always allowed.",
                 "- Prioritize work: continue an in-progress task; otherwise choose ready work feature → phase → task by ascending priority, respecting dependencies and blocked/waiting states. Prefer shortId or F00x/P00x/T00x refs. Find via feature_list / phase_list / task_list; read one entity via *_get(full=true).",
                 "- If edit/write guard blocks you, start the right task or use an explicit bypass.",
+                ...(extensionRules.length > 0
+                    ? [
+                        "",
+                        "Planner rules (extension; agent-only):",
+                        ...extensionRules.map((rule, index) => `${index + 1}. ${rule}`),
+                    ]
+                    : []),
                 "",
                 `Goal: ${project.goal || "(not set)"}`,
                 project.description ? `Description: ${project.description}` : "",