@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.5c1a3ff2

package/dist/resources/extensions/gsd/provider-payload-policy.js

@@ -2,12 +2,14 @@
  * Provider Payload Policy - ordered shaping of provider request payloads.
  *
  * The order is intentional:
- * 1. observation budgeting masks old tool results in auto-mode,
- * 2. display truncation caps tool-result text for every mode,
- * 3. the protected Source Context Block is appended after truncation,
- * 4. supported models receive the configured service tier.
+ * 1. superseded GSD context injections (memory/guided/forensics) are removed,
+ *    keeping only the latest, for every mode,
+ * 2. observation budgeting masks old tool results in auto-mode,
+ * 3. display truncation caps tool-result text for every mode,
+ * 4. the protected Source Context Block is appended after truncation,
+ * 5. supported models receive the configured service tier.
  */
-import { createObservationMask, createResponsesInputObservationMask, truncateContextResultMessages, truncateResponsesInputResultItems, } from "./context-masker.js";
+import { createObservationMask, createResponsesInputObservationMask, filterSupersededContextInjections, filterSupersededResponsesContextInjections, truncateContextResultMessages, truncateResponsesInputResultItems, } from "./context-masker.js";
 import { getSourceObservationStore, isAutoActive } from "./auto-runtime-state.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getEffectiveServiceTier, supportsServiceTier } from "./service-tier.js";
@@ -42,9 +44,18 @@ export function applyProviderPayloadPolicy({ payload, modelId, deps: overrides,
 }
 function applyContextManagement(payload, deps) {
     const config = deps.loadContextManagementConfig();
+    applyContextInjectionFilter(payload);
     applyObservationBudget(payload, config, deps.isAutoActive());
     applyDisplayTruncation(payload, config);
 }
+function applyContextInjectionFilter(payload) {
+    if (Array.isArray(payload.messages)) {
+        payload.messages = filterSupersededContextInjections(payload.messages);
+    }
+    if (Array.isArray(payload.input)) {
+        payload.input = filterSupersededResponsesContextInjections(payload.input);
+    }
+}
 function applyObservationBudget(payload, config, autoActive) {
     if (!autoActive || config?.observation_masking === false)
         return;

package/dist/resources/extensions/gsd/safety/destructive-guard.js

@@ -6,7 +6,7 @@
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
 const DESTRUCTIVE_PATTERNS = [
-    { pattern: /\brm\s+(-[^\s]*[rfRF][^\s]*\s+|.*\s+-[^\s]*[rfRF])/, label: "recursive delete" },
+    { pattern: /\brm\s+((?:-(?!-)[^\s]*[rR][^\s]*|--recursive)\s+|.*\s+(?:-(?!-)[^\s]*[rR][^\s]*|--recursive)(?:\s|$))/, label: "recursive delete" },
     { pattern: /\bgit\s+push\s+.*--force/, label: "force push" },
     { pattern: /\bgit\s+push\s+-f\b/, label: "force push" },
     { pattern: /\bgit\s+reset\s+--hard/, label: "hard reset" },

package/dist/resources/extensions/gsd/safety/evidence-collector.js

@@ -173,7 +173,7 @@ export function recordToolCall(toolCallId, toolName, input) {
             toolCallId,
             // gsd_exec / gsd_uat_exec carry the script body in `script` (or `code`);
             // bash-style tools use `command`/`cmd`; gsd_exec_search uses `query`.
-            command: String(input.command ?? input.script ?? input.cmd ?? input.code ?? input.query ?? ""),
+            command: formatExecutionEvidenceCommand(toolName, input),
             exitCode: -1,
             outputSnippet: "",
             timestamp: Date.now(),
@@ -196,6 +196,31 @@ export function recordToolCall(toolCallId, toolName, input) {
         });
     }
 }
+function pickString(input, ...keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+    }
+    return "";
+}
+function canonicalExecutionToolLabel(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    const mcpMatch = normalized.match(/^mcp__.+__(gsd_(?:uat_)?exec(?:_search)?)$/);
+    return mcpMatch?.[1] ?? normalized;
+}
+function formatExecutionEvidenceCommand(toolName, input) {
+    const body = pickString(input, "command", "script", "cmd", "code", "query");
+    const tool = canonicalExecutionToolLabel(toolName);
+    const purpose = pickString(input, "purpose");
+    const runtime = pickString(input, "runtime").toLowerCase();
+    const label = purpose && (tool === "gsd_exec" || tool === "gsd_uat_exec")
+        ? `${tool}${runtime ? ` ${runtime}` : ""}: ${purpose}`
+        : "";
+    if (label && body)
+        return `${label}\n${body}`;
+    return body || label;
+}
 /**
  * Record a tool execution result. Matches the entry by toolCallId (assigned
  * at dispatch time) and fills in exit code + output. Prior versions matched

package/dist/resources/extensions/gsd/safety/evidence-cross-ref.js

@@ -118,16 +118,25 @@ function latestClaimBatch(claimedEvidence) {
  */
 function findMatches(claimedCommand, bashCalls) {
     const normalized = claimedCommand.trim();
-    // Exact matches first
-    const exact = bashCalls.filter(b => b.command.trim() === normalized);
+    const exact = bashCalls.filter((b) => b.command.trim() === normalized);
+    // When an exact run exists, also consider wrapper-equivalent reruns (e.g.
+    // `cd ... && <command>`) so a newer pass is not shadowed by a stale exact
+    // failure. Do not merge arbitrary containing scripts: their exit code may
+    // belong to later work, not to the claimed verification command.
+    const scriptWrapped = bashCalls.filter((b) => {
+        const command = b.command.trim();
+        if (command.length === 0 || command === normalized)
+            return false;
+        return isWrapperEquivalentCommand(command, normalized);
+    });
     if (exact.length > 0)
-        return exact;
+        return [...exact, ...scriptWrapped];
     // Substring match: claimed is contained in actual or actual in claimed.
     // A claimed verification command typically appears verbatim inside a
     // larger gsd_exec script body (cd prefix, multi-line scripts), so
     // script-containing-claim is the common direction. Blank-command entries
     // must be excluded — `"x".includes("")` is true, so they'd match anything.
-    const substring = bashCalls.filter(b => b.command.trim().length > 0 &&
+    const substring = bashCalls.filter((b) => b.command.trim().length > 0 &&
         (b.command.includes(normalized) || normalized.includes(b.command)));
     if (substring.length > 0)
         return substring;
@@ -150,5 +159,21 @@ function findMatches(claimedCommand, bashCalls) {
         .map((match) => match.call);
 }
 function latestMatch(matches) {
-    return matches.reduce((latest, match) => (match.timestamp > latest.timestamp ? match : latest));
+    return matches.reduce((latest, match) => (match.timestamp >= latest.timestamp ? match : latest));
+}
+/** True when `actual` is the same command with only shell wrapper noise. */
+function isWrapperEquivalentCommand(actual, claimed) {
+    const claimIndex = actual.lastIndexOf(claimed);
+    if (claimIndex < 0)
+        return false;
+    const prefix = actual.slice(0, claimIndex).trim();
+    if (prefix.length > 0 && !/^cd\s+.+\s+&&$/.test(prefix))
+        return false;
+    const suffix = actual.slice(claimIndex + claimed.length).trim();
+    return suffix.length === 0 || isBenignWrapperSuffix(suffix);
+}
+function isBenignWrapperSuffix(suffix) {
+    if (/^;\s*echo\s+["']?[A-Z_]*EXIT=\$\?["']?$/.test(suffix))
+        return true;
+    return /^(?:(?:\d?>>?|&>)\s*\S+|\d?>&\d)(?:\s+(?:(?:\d?>>?|&>)\s*\S+|\d?>&\d))*$/.test(suffix);
 }

package/dist/resources/extensions/gsd/skill-activation.js

@@ -104,11 +104,24 @@ function resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, base) {
 /** Skill names must be lowercase alphanumeric with hyphens — reject anything else
  *  to prevent prompt injection via crafted directory names. */
 const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9-]*$/;
-function formatSkillActivationBlock(skillNames) {
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function formatSkillActivationBlock(skillNames, skillPaths) {
     const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
     if (safe.length === 0)
         return "";
-    const reads = safe.map(name => `Read the installed '${name}' skill file from <available_skills>`).join(". ");
+    const reads = safe.map(name => {
+        const path = skillPaths.get(name);
+        if (path)
+            return `Read the skill file at \`${escapeXml(path)}\``;
+        return `Find '${name}' in <available_skills>, copy its <location> value, and pass that exact path to read`;
+    }).join(". ");
     return `<skill_activation>${reads}.</skill_activation>`;
 }
 /**
@@ -149,6 +162,7 @@ export function buildSkillActivationBlock(params) {
     const visibleSkills = loaded;
     const manifestScopedSkills = filterSkillsByManifest(visibleSkills, params.unitType);
     const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
+    const installedSkillPaths = new Map(visibleSkills.map(skill => [normalizeSkillReference(skill.name), skill.filePath]));
     warnIfManifestHasMissingSkills(params.unitType, installedNames);
     const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
     const matched = new Set();
@@ -196,7 +210,7 @@ export function buildSkillActivationBlock(params) {
     const ordered = [...matched]
         .filter(name => installedNames.has(name) && !avoided.has(name))
         .sort();
-    const activationBlock = formatSkillActivationBlock(ordered);
+    const activationBlock = formatSkillActivationBlock(ordered, installedSkillPaths);
     // Omit recommendations when the system catalog is manifest-scoped for this
     // unit — skill names are already listed in <available_skills>.
     let recommendationsBlock = "";

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-markdown-edit.js

@@ -3,9 +3,10 @@
 //
 // gsd-pi's DB is canonical, but .gsd/*.md is the inter-tool contract. When
 // gsd-core edits a projection file, this handler detects the sha drift vs the
-// recorded baseline in .gsd/.compat.json and re-imports the affected entities
-// into the DB. The next renderAllFromDb pass re-projects; the write-time
-// invalidation hook then refreshes the marker entry, closing the loop.
+// recorded baseline in .gsd/.compat.json and re-imports from markdown with
+// status authority scoped to the affected milestone ids. The next
+// renderAllFromDb pass re-projects; the write-time invalidation hook then
+// refreshes the marker entry, closing the loop.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { computeProjectionSha, readCompatMarker, writeCompatMarker, } from "../../compat/compat-marker.js";
@@ -43,23 +44,36 @@ function detectExternalMarkdownEdit(_state, ctx) {
     return records;
 }
 /**
- * Idempotent repair: re-import hierarchy for the affected entities from
- * markdown into the DB, then update the marker entry so the next detect pass
- * sees the file as expected. migrateHierarchyToDb is itself idempotent
- * (upsert), so re-running this repair after a successful one is a no-op.
+ * Idempotent repair: re-import the hierarchy from markdown while allowing
+ * markdown status authority only for milestones named by the drifted file's
+ * marker entities, then update the marker entry so the next detect pass sees
+ * the file as expected. migrateHierarchyToDb is itself idempotent (upsert), so
+ * re-running this repair after a successful one is a no-op.
  */
 async function repairExternalMarkdownEdit(record, ctx) {
     try {
         // Dynamic imports break a module-init cycle: this handler ← registry ←
         // state.ts ← guided-flow.ts ← md-importer.ts ← (this handler's old static
         // import). Deferring to repair time keeps module load cycle-free.
-        const { migrateHierarchyToDb } = await import("../../md-importer.js");
+        const { migrateHierarchyToDb, milestoneIdsFromEntities } = await import("../../md-importer.js");
         const { invalidateStateCache } = await import("../../state.js");
-        // Scoped re-import. migrateHierarchyToDb walks the whole tree but is a
-        // cheap upsert; per-entity scoping would require decomposing it, which is
-        // out of scope for v1. The cost is bounded by tree size and runs at most
-        // once per reconcile pass (MAX_PASSES=2).
-        migrateHierarchyToDb(ctx.basePath);
+        // #027: migrateHierarchyToDb walks the whole tree (a cheap upsert), so
+        // without scoping every projection rides along with markdown *status*
+        // authority. That lets an unrelated file that is stale from gsd-pi's own
+        // miss silently revert a reopened slice/milestone. Scope status authority to
+        // exactly the milestone(s) this drifted file projects.
+        //
+        // Step 1: the marker's `entities` are DB ids (`M001`, `M001/S01`,
+        // `M001/S01/T01`), so the milestone id is always the first `/`-segment —
+        // layout-independent (legacy `milestones/<MID>/…` and flat `phases/NN-slug/…`
+        // both resolve the same way), no projectionPath parsing needed. An empty set
+        // (no resolvable entities) preserves DB status everywhere: fail toward
+        // protecting the DB, not toward markdown authority.
+        const statusAuthoritativeMilestones = milestoneIdsFromEntities(record.entities);
+        if (statusAuthoritativeMilestones.size === 0) {
+            logWarning("reconcile", `external-markdown-edit: no milestone scope resolved for ${record.projectionPath}; preserving DB status for all milestones`);
+        }
+        migrateHierarchyToDb(ctx.basePath, { statusAuthoritativeMilestones });
         invalidateStateCache();
     }
     catch (err) {

package/dist/resources/extensions/gsd/state-reconciliation/drift/external-planning-edit.js

@@ -3,7 +3,8 @@
 // Parallel to external-markdown-edit.ts. Detects sha drift between the compat
 // marker's planning.projections/passthrough and current .planning/ files.
 //
-// Modeled files (projections): re-imported via parsePlanningDirectory → DB.
+// Modeled files (projections): re-imported via parsePlanningDirectory → DB,
+// with markdown status authority scoped to their marker entity milestone ids.
 // Passthrough files (un-modeled docs): sha refreshed, content untouched.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -115,12 +116,21 @@ async function repairExternalPlanningEdit(record, ctx) {
         const { parsePlanningDirectory } = await import("../../migrate/parser.js");
         const { transformToGSD } = await import("../../migrate/transformer.js");
         const { writeGSDDirectory } = await import("../../migrate/writer.js");
-        const { migrateHierarchyToDb } = await import("../../md-importer.js");
+        const { migrateHierarchyToDb, milestoneIdsFromEntities } = await import("../../md-importer.js");
         const { invalidateStateCache } = await import("../../state.js");
         const parsed = await parsePlanningDirectory(join(ctx.basePath, ".planning"));
         const gsdProject = transformToGSD(parsed);
         await writeGSDDirectory(gsdProject, ctx.basePath);
-        migrateHierarchyToDb(ctx.basePath);
+        // #027: scope status authority to the milestone(s) this drifted .planning/
+        // file projects (first `/`-segment of its DB entity ids), so a stale
+        // checkbox in an unrelated projection can't revert a reopened slice/milestone
+        // in the DB. Unseeded files carry no entities → empty set → preserve DB
+        // status everywhere (fail toward the DB, log the breadcrumb).
+        const statusAuthoritativeMilestones = milestoneIdsFromEntities(record.entities);
+        if (statusAuthoritativeMilestones.size === 0) {
+            logWarning("reconcile", `external-planning-edit: no milestone scope resolved for ${record.projectionPath}; preserving DB status for all milestones`);
+        }
+        migrateHierarchyToDb(ctx.basePath, { statusAuthoritativeMilestones });
         invalidateStateCache();
     }
     catch (err) {

package/dist/resources/extensions/gsd/stop-notice.js

@@ -50,8 +50,22 @@ export function isTerminalNotice(message) {
 export function isNonBlockingPauseNotice(message) {
     return message.includes("idempotent advance: unit already active");
 }
+/**
+ * A picker / next-action menu that could not render in a non-interactive
+ * (headless / RPC) session. Both wordings originate from the menu-unavailable
+ * helpers (`notifyCommandMenuUnavailable` and `notifyPickerCommandNeedsInteractiveMenu`
+ * in next-action-ui.ts / command-feedback.ts). Headless `auto`/`next` cannot
+ * answer such a menu, so the run has dead-ended and needs operator intervention.
+ * Classify it as blocked so the headless host exits 10 instead of idling
+ * forever waiting for a completion signal that never comes. (#1294)
+ */
+export function isInteractiveMenuUnavailableNotice(message) {
+    return (message.includes("menu could not be shown in this session") ||
+        message.includes("did not start:"));
+}
 export function isBlockedNoticeMessage(message) {
     return (message.includes("blocked:") ||
         (isPauseNotice(message) && !isNonBlockingPauseNotice(message)) ||
-        isManualResolutionNotice(message));
+        isManualResolutionNotice(message) ||
+        isInteractiveMenuUnavailableNotice(message));
 }

package/dist/resources/extensions/gsd/sync-lock.js

@@ -6,8 +6,9 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unl
 import { dirname, join } from "node:path";
 const STALE_THRESHOLD_MS = 60_000; // 60 seconds
 const DEFAULT_TIMEOUT_MS = 0; // fail fast; sync waits block the JS event loop
-function lockFilePath(basePath) {
-    return join(basePath, ".gsd", "sync.lock");
+const DEFAULT_LOCK_NAME = "sync.lock";
+function lockFilePath(basePath, lockName = DEFAULT_LOCK_NAME) {
+    return join(basePath, ".gsd", lockName);
 }
 /** True if the given PID is alive in the current process namespace. */
 function isPidAlive(pid) {
@@ -71,8 +72,8 @@ function tryCreateLockFile(lp, payload) {
  * I/O, and UI work on Node's single JS thread. The timeout argument remains
  * accepted for compatibility but is intentionally not used for sync waiting.
  */
-export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS) {
-    const lp = lockFilePath(basePath);
+export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS, lockName = DEFAULT_LOCK_NAME) {
+    const lp = lockFilePath(basePath, lockName);
     const lockData = JSON.stringify({ pid: process.pid, acquired_at: new Date().toISOString() }, null, 2);
     while (true) {
         // First try the fast path: atomic create. No check-then-write race.
@@ -82,7 +83,12 @@ export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS) {
             }
         }
         catch {
-            /* unexpected — fall through to retry */
+            // tryCreateLockFile only throws for non-EEXIST errors — a persistently
+            // uncreatable lock path (dangling-symlink parent, ENOTDIR, read-only FS).
+            // Retrying would spin the loop forever with no progress condition,
+            // blocking the JS event loop. Fail open like a contended lock so callers
+            // proceed (racy but functional) instead of hanging.
+            return { acquired: false };
         }
         // File exists. Decide whether to steal (stale + owner dead) or skip.
         let canSteal = false;
@@ -125,8 +131,8 @@ export function acquireSyncLock(basePath, _timeoutMs = DEFAULT_TIMEOUT_MS) {
 /**
  * Release the advisory sync lock. No-op if lock file does not exist.
  */
-export function releaseSyncLock(basePath) {
-    const lp = lockFilePath(basePath);
+export function releaseSyncLock(basePath, lockName = DEFAULT_LOCK_NAME) {
+    const lp = lockFilePath(basePath, lockName);
     try {
         if (existsSync(lp)) {
             unlinkSync(lp);

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -92,6 +92,11 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# planning_subagents:
+#   plan-milestone:
+#     allowed: [scout, planner, security]
+#   plan-slice:
+#     allowed: [scout, planner, reviewer, security]
 # language:
 # experimental:
 #   rtk: false

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -12,10 +12,10 @@
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { isClosedStatus } from "../status-guards.js";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, getUnresolvedBlockingReworkFindingsForTask, getBlockingReworkFindingsForTask, applyReworkResolutions, } from "../gsd-db.js";
 import { getWorkflowDatabasePath, ensureWorkflowDbAtPath } from "../db-workspace.js";
 import { getGatesForTurn } from "../gate-registry.js";
-import { gsdProjectionRoot, clearPathCache, resolveMilestonePath, resolveSlicePath } from "../paths.js";
+import { buildFlatTaskFileName, buildTaskFileName, gsdProjectionRoot, clearPathCache, legacyMilestonesDir, resolveMilestonePath, resolveSlicePath, } from "../paths.js";
 import { resolveCanonicalMilestoneRoot } from "../worktree-manager.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
@@ -34,13 +34,20 @@ function taskSummaryPath(basePath, milestoneId, sliceId, taskId) {
     // a legacy layout and breaks all subsequent path resolution for the session.
     const slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
     const phaseDir = resolveMilestonePath(basePath, milestoneId);
-    if (slicePath && phaseDir && slicePath !== phaseDir) {
-        // Legacy layout: the slice has its own slices/SID/ subdir → tasks/ subdir
-        return join(slicePath, "tasks", `${taskId}-SUMMARY.md`);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacy = phaseDir
+        ? phaseDir.startsWith(legacyBase + "/") || phaseDir.startsWith(legacyBase + "\\")
+        : false;
+    if (isLegacy && phaseDir) {
+        // Legacy layout: the slice has its own slices/SID/ subdir → tasks/ subdir.
+        const legacySlicePath = slicePath && slicePath !== phaseDir
+            ? slicePath
+            : join(phaseDir, "slices", sliceId);
+        return join(legacySlicePath, "tasks", buildTaskFileName(taskId, "SUMMARY"));
     }
     if (phaseDir) {
         // Flat-phase: task summaries go in the phase dir (no tasks/ subdir)
-        return join(phaseDir, `${taskId}-SUMMARY.md`);
+        return join(phaseDir, buildFlatTaskFileName(sliceId, taskId, "SUMMARY"));
     }
     // Fallback: legacy hardcoded path (milestone/slice dir not on disk yet)
     return join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks", `${taskId}-SUMMARY.md`);
@@ -107,6 +114,44 @@ export function normalizeListParam(value) {
  * Build a TaskRow-shaped object from CompleteTaskParams so the unified
  * renderSummaryContent() can be used at completion time (#2720).
  */
+function normalizeReworkResolution(params) {
+    return (params.reworkResolution ?? []).map((resolution) => ({
+        milestoneId: params.milestoneId,
+        sliceId: params.sliceId,
+        taskId: params.taskId,
+        findingId: resolution.findingId,
+        status: resolution.status,
+        evidence: resolution.evidence,
+        decisionRef: resolution.decisionRef,
+    }));
+}
+function unresolvedReworkError(missingFindingIds) {
+    const plural = missingFindingIds.length === 1 ? "finding" : "findings";
+    return `unresolved blocking rework ${plural}: ${missingFindingIds.join(", ")} — provide reworkResolution entries with status resolved and evidence, or status deferred-with-override with evidence and decisionRef, before completing the task`;
+}
+function satisfiesBlockingReworkFinding(resolution) {
+    if (resolution.evidence.trim().length === 0)
+        return false;
+    if (resolution.status === "resolved")
+        return true;
+    return (resolution.decisionRef ?? "").trim().length > 0;
+}
+/**
+ * Restore rework findings to their pre-completion state.
+ *
+ * The completion transaction flips blocking findings to resolved/
+ * deferred-with-override via applyReworkResolutions. When a later projection
+ * or escalation write fails and we compensate by reverting the task to
+ * `pending`, we must also revert those findings. Otherwise a retry sees no
+ * unresolved blocking findings (getUnresolvedBlockingReworkFindingsForTask
+ * only returns `pending` rows) and completes the task with the blocking gate
+ * silently skipped.
+ */
+function revertAppliedReworkResolutions(snapshot) {
+    if (snapshot.length === 0)
+        return;
+    applyReworkResolutions(snapshot);
+}
 function paramsToTaskRow(params, completedAt) {
     return {
         milestone_id: params.milestoneId,
@@ -182,6 +227,7 @@ export async function handleCompleteTask(params, basePath) {
     let guardError = null;
     let summaryMd = "";
     let repairTaskSummaryRow = null;
+    let appliedReworkSnapshot = [];
     const rollbackDbPath = getWorkflowDatabasePath();
     // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
     // Building the artifact runs the full shape validation (2-4 options, unique
@@ -192,6 +238,7 @@ export async function handleCompleteTask(params, basePath) {
     // no escalation recorded, and the loop would silently advance past it.
     // The filesystem write happens later (after side effects) because that's
     // the cheapest ordering and validation is where 99% of failures live.
+    const reworkResolutions = normalizeReworkResolution(params);
     let validatedEscalationArtifact = null;
     let escalationWriteEnabled = false;
     if (params.escalation) {
@@ -231,6 +278,17 @@ export async function handleCompleteTask(params, basePath) {
             return;
         }
         const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
+        const unresolvedRework = getUnresolvedBlockingReworkFindingsForTask(params.milestoneId, params.sliceId, params.taskId);
+        const resolvedFindingIds = new Set(reworkResolutions
+            .filter(satisfiesBlockingReworkFinding)
+            .map((resolution) => resolution.findingId));
+        const missingFindingIds = unresolvedRework
+            .filter((finding) => !resolvedFindingIds.has(finding.finding_id))
+            .map((finding) => finding.finding_id);
+        if (missingFindingIds.length > 0) {
+            guardError = unresolvedReworkError(missingFindingIds);
+            return;
+        }
         if (existingTask && isClosedStatus(existingTask.status)) {
             // Stale-turn path: a timed-out turn that was superseded by recovery
             // can still reach this code when its LLM call eventually returns and
@@ -278,6 +336,33 @@ export async function handleCompleteTask(params, basePath) {
             keyDecisions: params.keyDecisions ?? [],
             fullSummaryMd: summaryMd,
         });
+        // Only persist resolutions that actually satisfy the evidence
+        // requirement. The guard above admits a finding as long as ONE satisfying
+        // entry exists, but applyReworkResolutions writes by findingId and lets the
+        // last entry win. Persisting every entry would let a later non-satisfying
+        // duplicate (empty evidence, or deferred-with-override without decisionRef)
+        // overwrite a valid resolution and leave the finding non-pending without
+        // acceptable evidence. Filtering with the same predicate the guard uses
+        // keeps the applied set and the gate consistent.
+        const resolutionsToApply = reworkResolutions.filter(satisfiesBlockingReworkFinding);
+        if (resolutionsToApply.length > 0) {
+            // Snapshot the pre-resolution state of the findings we're about to
+            // change so a compensating rollback can restore them exactly (see
+            // revertAppliedReworkResolutions).
+            const resolvedFindingIdsForSnapshot = new Set(resolutionsToApply.map((r) => r.findingId));
+            appliedReworkSnapshot = getBlockingReworkFindingsForTask(params.milestoneId, params.sliceId, params.taskId)
+                .filter((finding) => resolvedFindingIdsForSnapshot.has(finding.finding_id))
+                .map((finding) => ({
+                milestoneId: params.milestoneId,
+                sliceId: params.sliceId,
+                taskId: params.taskId,
+                findingId: finding.finding_id,
+                status: finding.status,
+                evidence: finding.evidence,
+                decisionRef: finding.decision_ref,
+            }));
+            applyReworkResolutions(resolutionsToApply);
+        }
         for (const evidence of (params.verificationEvidence ?? [])) {
             insertVerificationEvidence({
                 taskId: params.taskId,
@@ -340,6 +425,7 @@ export async function handleCompleteTask(params, basePath) {
             ensureWorkflowDbAtPath(rollbackDbPath);
             deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
             updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, "pending");
+            revertAppliedReworkResolutions(appliedReworkSnapshot);
             invalidateStateCache();
             rollbackSucceeded = true;
         }
@@ -430,6 +516,7 @@ export async function handleCompleteTask(params, basePath) {
                 try {
                     deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
                     updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+                    revertAppliedReworkResolutions(appliedReworkSnapshot);
                     invalidateStateCache();
                     logWarning("tool", `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} after escalation write failure; SUMMARY.md left on disk for retry.`);
                 }
@@ -447,6 +534,7 @@ export async function handleCompleteTask(params, basePath) {
             try {
                 deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
                 updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+                revertAppliedReworkResolutions(appliedReworkSnapshot);
                 invalidateStateCache();
                 logWarning("tool", `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} because hard-blocker escalation handling is disabled; SUMMARY.md left on disk for retry.`);
             }

package/dist/resources/extensions/gsd/tools/plan-task.js

@@ -5,7 +5,7 @@ import { getGateIdsForTurn } from "../gate-registry.js";
 import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning, insertGateRow, setSliceSketchFlag } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb, renderPlanFromDb } from "../markdown-renderer.js";
-import { resolveTasksDir } from "../paths.js";
+import { resolveMilestonePath, resolveSlicePath } from "../paths.js";
 import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -193,21 +193,19 @@ export async function handlePlanTask(rawParams, basePath) {
         return { error: guardError };
     }
     try {
-        const renderResult = await renderTaskPlanFromDb(basePath, params.milestoneId, params.sliceId, params.taskId);
-        // Flat-phase: tasks live as checkboxes in the slice plan's <tasks> block,
-        // not as standalone TID-PLAN.md files. Re-render the slice plan so the
-        // new/updated task appears in the plan file that gsd-core reads.
-        // Guard: resolveTasksDir is null in flat-phase (no tasks/ subdir exists).
+        const milestonePath = resolveMilestonePath(basePath, params.milestoneId);
+        const slicePath = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
+        const isLegacySliceLayout = Boolean(milestonePath && slicePath && slicePath !== milestonePath);
+        let renderedPath;
         let slicePlanSynced = false;
-        try {
-            const tDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
-            if (!tDir) {
-                await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
-                slicePlanSynced = true;
-            }
+        if (isLegacySliceLayout) {
+            const renderResult = await renderTaskPlanFromDb(basePath, params.milestoneId, params.sliceId, params.taskId);
+            renderedPath = renderResult.taskPlanPath;
         }
-        catch (syncErr) {
-            logWarning("tool", `plan-task: slice-plan sync failed: ${syncErr.message}`);
+        else {
+            const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+            renderedPath = renderResult.planPath;
+            slicePlanSynced = true;
         }
         if (slicePlanSynced) {
             setSliceSketchFlag(params.milestoneId, params.sliceId, false);
@@ -234,7 +232,7 @@ export async function handlePlanTask(rawParams, basePath) {
             milestoneId: params.milestoneId,
             sliceId: params.sliceId,
             taskId: params.taskId,
-            taskPlanPath: renderResult.taskPlanPath,
+            taskPlanPath: renderedPath,
         };
     }
     catch (err) {