@agent-plan/pi-adapter 0.2.22 → 0.2.23

package/dist/index.js

@@ -9,7 +9,8 @@
  *  - 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, markFeatureRead, markPhaseRead, markTaskRead, contextReadEligibility, hasReadRequirements, markRequirementRead, invalidateReads } 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";
@@ -243,10 +244,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 +319,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 +558,7 @@ function statusIcon(status) {
     const icons = {
         draft: "📄", discovery: "🔍", planned: "📋",
         "in-progress": "🚧", done: "✅", blocked: "🚫", canceled: "❌",
+        rejected: "❌", deferred: "⏳", waiting: "⏱️",
     };
     return icons[status] ?? "❓";
 }
@@ -626,20 +630,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 +685,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 +756,10 @@ async function startServer(ctx, requestedPort, visibility = "lan") {
         catch { }
     }
 }
+function enablePlannerSession() {
+    plannerSessionEnabled = true;
+    contextBlockDirty = true;
+}
 function disablePlannerSession() {
     plannerSessionEnabled = false;
     startupResumePromptPending = false;
@@ -759,6 +786,7 @@ export default function planPiExtension(pi) {
     capturedPi = pi;
     // ── Restore on session start/reload ─────────────────────────────────
     pi.on("session_start", async (_event, ctx) => {
+        invalidateReads();
         try {
             ctx.ui.addAutocompleteProvider((current) => ({
                 triggerCharacters: ["/", " "],
@@ -1134,6 +1162,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 +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;
@@ -1182,12 +1212,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 +1228,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 +1242,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 +1465,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 +1491,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") {
@@ -2129,8 +2160,9 @@ 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;
                     }
                     applyTaskLifecycleDates(task, normalizedStatus, now);
                 }
@@ -2168,6 +2200,21 @@ export default function planPiExtension(pi) {
                         return;
                     }
                 }
+                if (phase) {
+                    const contextEligibility = contextReadEligibility(task.id, phase.id, phase.featureId);
+                    if (!contextEligibility.eligible) {
+                        ctx.ui.notify(`Task start denied: context reads required. ${contextEligibility.reason}`, "warning");
+                        return;
+                    }
+                    const linkedRequirementIds = [
+                        ...(await st.linkedRequirementsForPhase(phase.id)).map((r) => r.id),
+                        ...(phase.featureId ? (await st.linkedRequirementsForFeature(phase.featureId)).map((r) => r.id) : []),
+                    ];
+                    if (!hasReadRequirements(linkedRequirementIds)) {
+                        ctx.ui.notify("Task start denied: read the requirements linked to this phase and feature first.", "warning");
+                        return;
+                    }
+                }
                 if (task.status === "in-progress") {
                     ctx.ui.notify(`Task "${task.title}" is already in-progress.`, "info");
                     return;
@@ -2341,7 +2388,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") {
@@ -2514,7 +2565,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(() => { });
@@ -2747,6 +2798,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) => markRequirementRead(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 +2819,21 @@ 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,
                 createdAt: now,
                 updatedAt: now,
             };
@@ -2804,14 +2862,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();
@@ -3021,6 +3087,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",
@@ -3077,11 +3160,13 @@ export default function planPiExtension(pi) {
             // 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 firstHeadingText = firstLine.replace(/^#+\s*/, "").trim();
-            const isGeneric = !firstHeadingText || /^(handoff|canonical handoff|session handoff)$/i.test(firstHeadingText);
-            if (!title && isGeneric) {
+            const genericTitlePattern = /^(handoff|canonical handoff|session handoff)$/i;
+            const effectiveHeadingText = (title && title.length > 0) ? title : firstHeadingText;
+            const isGeneric = !effectiveHeadingText || genericTitlePattern.test(effectiveHeadingText);
+            if (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 },
+                    details: { error: "generic title", firstHeadingText: effectiveHeadingText || firstHeadingText },
                 };
             }
             // Normalize: if a title is provided, replace or prepend the H1 so the first line is the title.
@@ -3191,6 +3276,8 @@ export default function planPiExtension(pi) {
             if (!resolvedFeature.ok)
                 return { content: [{ type: "text", text: resolvedFeature.error }], details: {} };
             const feature = resolvedFeature.feature;
+            if (params.full)
+                markFeatureRead(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"}` : ""})`;
@@ -3489,6 +3576,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)
+                markPhaseRead(phase.id, phase.featureId);
             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 +3602,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 +3625,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: "",
@@ -3823,10 +3915,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 +3928,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)
+                markTaskRead(found.task.id, found.phase.id, found.phase.featureId);
             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 +3978,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,18 +4007,18 @@ 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,
@@ -3912,8 +4033,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 +4088,12 @@ 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 !== undefined &&
                 params.status !== found.task.status &&
                 needsMotivation(found.task.status, params.status)) {
@@ -4061,14 +4188,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 +4219,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 +4272,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,20 +4285,20 @@ 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 } } : {}) },
             };
         },
     });
@@ -4191,7 +4319,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 +4329,19 @@ 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 contextEligibility = contextReadEligibility(target.task.id, target.phase.id, target.phase.featureId);
+            if (!contextEligibility.eligible) {
+                return { content: [{ type: "text", text: `Task switch denied: context reads required. ${contextEligibility.reason}` }], details: contextEligibility };
+            }
+            const linkedRequirementIds = [
+                ...(await st.linkedRequirementsForPhase(target.phase.id)).map((requirement) => requirement.id),
+                ...(target.phase.featureId ? (await st.linkedRequirementsForFeature(target.phase.featureId)).map((requirement) => requirement.id) : []),
+            ];
+            if (!hasReadRequirements(linkedRequirementIds)) {
+                return { content: [{ type: "text", text: "Task switch denied: read the requirements linked to the target phase and feature before switching." }], details: { requirementIds: linkedRequirementIds } };
             }
             const eligibility = checkExplicitTaskStart(features, phases, target.task.id, project.workDeviations);
             if (!eligibility.eligible)
@@ -4213,7 +4352,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 +4371,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 +4379,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 +4401,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 +4432,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,7 +4449,7 @@ 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. BEFORE calling, read task_get(full=true), then its parent phase_get(full=true), then its parent feature_get(full=true), in that exact order. Read linked requirements with requirement_list when present. A different active task must first be suspended through task_switch.",
         parameters: Type.Object({
             taskId: Type.String({ description: "Task ref: F00x/P00x/T00x, bare T00x (global), 5-char shortId, UUID, or title to start" }),
         }),
@@ -4326,12 +4466,22 @@ export default function planPiExtension(pi) {
                 return { content: [{ type: "text", text: `Task ${task.id} is already in-progress.` }], details: 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();
+            const contextEligibility = contextReadEligibility(task.id, found.phase.id, found.phase.featureId);
+            if (!contextEligibility.eligible) {
+                return { content: [{ type: "text", text: `Task start denied: context reads required. ${contextEligibility.reason}` }], details: contextEligibility };
+            }
+            const linkedRequirementIds = [
+                ...(await st.linkedRequirementsForPhase(found.phase.id)).map((requirement) => requirement.id),
+                ...(found.phase.featureId ? (await st.linkedRequirementsForFeature(found.phase.featureId)).map((requirement) => requirement.id) : []),
+            ];
+            if (!hasReadRequirements(linkedRequirementIds)) {
+                return { content: [{ type: "text", text: "Task start denied: read the requirements linked to the task's phase and feature first." }], details: { 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);
+            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 };
             }
@@ -4339,9 +4489,27 @@ export default function planPiExtension(pi) {
                 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 };
             }
-            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 +4520,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 {
@@ -4390,7 +4560,11 @@ export default function planPiExtension(pi) {
             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 };
+            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,
+                ...(resumeProposal ? { resumeRequired: resumeProposal.structured } : {}),
+            };
         },
     });
     pi.registerTool({
@@ -4413,8 +4587,8 @@ 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 };
+            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 {
@@ -4463,7 +4637,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 +4824,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 +4896,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 = [
@@ -4836,12 +5011,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 task_get(full=true), then its parent phase_get(full=true), then its parent feature_get(full=true), in that exact order. Read linked requirements with requirement_list when present. task_start and task_switch reject work until these reads are complete; only then touch code. AFTER finishing a task: task_complete.",
                 "- 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}` : "",