@opengsd/gsd-pi 1.4.0 → 1.5.0

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -34,6 +34,15 @@ const VALID_POST_UNIT_HOOK_ON_BLOCK_ACTIONS = new Set([
     "pause",
 ]);
 const VALID_GATE_EVALUATE_SLICE_GATES = new Set(getGateIdsForTurn("gate-evaluate"));
+/** Cross-axis warnings that only apply to the effective (merged) preference shape. */
+export function crossAxisPreferenceWarnings(preferences) {
+    if (preferences.mode === "team" && preferences.workspace?.mode === "parent") {
+        return [
+            "mode:team + workspace.mode:parent: team branch-push/PR resolves at the project root and will not push child repositories — see docs/dev/ADR-044",
+        ];
+    }
+    return [];
+}
 export function validatePreferences(preferences) {
     const errors = [];
     const warnings = [];
@@ -489,8 +498,12 @@ export function validatePreferences(preferences) {
     }
     // ─── Remote Questions ───────────────────────────────────────────────
     if (preferences.remote_questions !== undefined) {
-        if (preferences.remote_questions && typeof preferences.remote_questions === "object") {
-            validated.remote_questions = preferences.remote_questions;
+        const remoteQuestions = preferences.remote_questions;
+        if (typeof remoteQuestions === "object" && remoteQuestions !== null) {
+            validated.remote_questions = remoteQuestions;
+        }
+        else if (remoteQuestions === false) {
+            // Explicit disable for a globally-configured remote questions channel.
         }
         else {
             errors.push("remote_questions must be an object");
@@ -1524,6 +1537,15 @@ export function validatePreferences(preferences) {
         else {
             errors.push("workspace must be an object");
         }
+        // parent mode is behavioral: it must coordinate at least one declared
+        // child repository. Without one it is indistinguishable from project
+        // mode, so reject it explicitly rather than silently degrading.
+        if (validated.workspace?.mode === "parent") {
+            const childRepoCount = validated.workspace.repositories ? Object.keys(validated.workspace.repositories).length : 0;
+            if (childRepoCount === 0) {
+                errors.push('workspace.mode "parent" requires at least one repository under workspace.repositories');
+            }
+        }
     }
     // ─── Enhanced Verification ──────────────────────────────────────────────────
     if (preferences.enhanced_verification !== undefined) {
@@ -1596,5 +1618,6 @@ export function validatePreferences(preferences) {
             errors.push(`language must be a non-empty string up to 50 characters with no newlines (e.g. "Chinese", "de", "日本語")`);
         }
     }
+    warnings.push(...crossAxisPreferenceWarnings(validated));
     return { preferences: validated, errors, warnings };
 }

package/dist/resources/extensions/gsd/preferences.js

@@ -19,7 +19,7 @@ import { logWarning } from "./workflow-logger.js";
 import { DEFAULT_TOKEN_PROFILE, resolveProfileDefaults as _resolveProfileDefaults, VALID_TOKEN_PROFILES, resolveDisabledModelProvidersFromPreferences, } from "./preferences-models.js";
 import { nativeHasCommittedHead, nativeIsRepo } from "./native-git-bridge.js";
 import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, formatSkillRef, } from "./preferences-types.js";
-import { validatePreferences } from "./preferences-validation.js";
+import { crossAxisPreferenceWarnings, validatePreferences } from "./preferences-validation.js";
 import { gsdHome } from "./gsd-home.js";
 // ─── Re-exports: validation ─────────────────────────────────────────────────
 export { validatePreferences } from "./preferences-validation.js";
@@ -203,6 +203,7 @@ function effectivePreferencesCacheKey(basePath, opts) {
         project: projectPreferencesCandidatePaths(basePath).map(preferencesFileSignature),
         availableModelIds: opts?.availableModelIds ?? null,
         preferredModelId: opts?.preferredModelId ?? null,
+        skipProfileDefaults: opts?.skipProfileDefaults === true,
     });
 }
 function cloneLoadedPreferences(loaded) {
@@ -264,7 +265,7 @@ export function loadEffectiveGSDPreferences(basePath, opts) {
     else {
         profileForDefaults = DEFAULT_TOKEN_PROFILE;
     }
-    if (profileForDefaults) {
+    if (profileForDefaults && !opts?.skipProfileDefaults) {
         const profileDefaults = _resolveProfileDefaults(profileForDefaults, opts?.availableModelIds, result.preferences.dynamic_routing, opts?.preferredModelId);
         const defaultsToApply = explicitProfile
             ? profileDefaults
@@ -282,9 +283,35 @@ export function loadEffectiveGSDPreferences(basePath, opts) {
         };
     }
     result = stripInheritedPlanningDepth(result, projectHasPlanningDepth);
+    result = appendCrossAxisPreferenceWarnings(result);
     cacheEffectivePreferences(cacheKey, result);
     return result;
 }
+function appendCrossAxisPreferenceWarnings(loaded) {
+    const crossWarnings = crossAxisPreferenceWarnings(loaded.preferences);
+    const existingMessages = new Set([
+        ...(loaded.warnings ?? []),
+        ...(loaded.diagnostics ?? []).map((diagnostic) => diagnostic.message),
+    ]);
+    const newWarnings = crossWarnings.filter((message) => !existingMessages.has(message));
+    if (newWarnings.length === 0)
+        return loaded;
+    return {
+        ...loaded,
+        warnings: [...(loaded.warnings ?? []), ...newWarnings],
+        diagnostics: [
+            ...(loaded.diagnostics ?? []),
+            ...newWarnings.map((message) => ({
+                path: loaded.path,
+                scope: loaded.scope,
+                severity: "warning",
+                kind: "validation",
+                message,
+                sanitized: true,
+            })),
+        ],
+    };
+}
 function withoutProfilePhaseDefaults(defaults) {
     if (defaults.phases === undefined)
         return defaults;

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -32,6 +32,8 @@ Before planning, validate roadmap assumptions against code and dependency summar
 
 If slice research is inlined, trust its architectural findings, but verify every concrete file path you place in task `inputs` or `expectedOutput` against the current tree or prior/same-task outputs. Explore enough code to confirm paths, boundaries, and verification. Executors later get only task plans, slice excerpt, and prior summaries, so put required paths, steps, inputs, and outputs in task plans.
 
+{{repoRegistry}}
+
 {{executorContextConstraints}}
 
 ## Planning Rules
@@ -45,8 +47,8 @@ If slice research is inlined, trust its architectural findings, but verify every
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
 8. Task `verify` commands must be safe, simple commands. Do not use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`. If multiple checks are needed, create a small test file and run it with `node --test` or a package test script, or use separate simple commands joined only with `&&`. For absence checks, verify a pattern does not exist with `! grep -q 'pattern' file` or `! rg -q 'pattern' file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches, and the verification gate treats that as failure.
-9. Each task persisted with `gsd_plan_task` needs the exact shape: `milestoneId`, `sliceId`, `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. Any npm package name in a task description's install/add instructions (`npm install`, `yarn add`, `pnpm add`) or in `require('...')` or `import ... from '...'` code examples is subject to pre-execution registry validation; reference only packages that exist on the public npm registry, and remove or correct any package name that is not real. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, tests, or describes — those belong in `inputs`, `verify`, `description`, or slice success criteria. If a task is a pure verification or test task that produces no new files, `expectedOutput` must be `[]`; if it writes a test-result log or assertion output file, list only that concrete file path. A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
-10. Persist incrementally through DB-backed tools. First call `gsd_plan_slice` with `milestoneId`, `sliceId`, `goal`, and optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact`; omit `tasks` for this metadata call. Then call `gsd_plan_task` once per task, using the task shape above. Each successful tool call saves progress and re-renders `{{outputPath}}` from DB. The DB-backed tools are the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
+9. Each task persisted with `gsd_plan_task` needs the exact shape: `milestoneId`, `sliceId`, `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. In a parent workspace (when a Declared Repositories block is present above), also set `targetRepositories` to the repository id(s) the task touches. `description` should contain the Why / Do / Done-when narrative. Any npm package name in a task description's install/add instructions (`npm install`, `yarn add`, `pnpm add`) or in `require('...')` or `import ... from '...'` code examples is subject to pre-execution registry validation; reference only packages that exist on the public npm registry, and remove or correct any package name that is not real. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, tests, or describes — those belong in `inputs`, `verify`, `description`, or slice success criteria. If a task is a pure verification or test task that produces no new files, `expectedOutput` must be `[]`; if it writes a test-result log or assertion output file, list only that concrete file path. A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
+10. Persist incrementally through DB-backed tools. First call `gsd_plan_slice` with `milestoneId`, `sliceId`, `goal`, and optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact` (and `targetRepositories` in a parent workspace, to set the slice-wide default); omit `tasks` for this metadata call. Then call `gsd_plan_task` once per task, using the task shape above. Each successful tool call saves progress and re-renders `{{outputPath}}` from DB. The DB-backed tools are the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
 11. Self-audit before finishing: goal/demo closure, requirement coverage, deliverable coverage audit (cross-check every file listed in CONTEXT.md `## Scope` / `### In Scope` against task `files` or `expectedOutput`), locked decisions, concrete paths, dependency order, wiring, scope size, proof truthfulness, feature completeness, and quality gates. Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable.
 12. If planning creates structural decisions, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
 13. {{commitInstruction}}

package/dist/resources/extensions/gsd/redact-secrets.js

@@ -0,0 +1,37 @@
+// redact-secrets.ts
+// Best-effort redaction of secret-shaped substrings before persisting free text
+// (exec-sandbox output, activity-log session entries) to disk under .gsd/, which
+// the secret scanner skips. Patterns mirror scripts/secret-scan.mjs.
+const PLACEHOLDER = "«redacted»";
+// Each secret shape. Global flag so replace() catches every occurrence in a line.
+// Order is not significant — matches are replaced independently.
+const PATTERNS = [
+    /AKIA[0-9A-Z]{16}/g, // AWS access key id
+    /(api[_-]?key|apikey|api[_-]?secret)[ \t]*[:=][ \t]*['"][0-9a-zA-Z_./-]{20,}['"]/gi,
+    /(secret|token|password|passwd|pwd|credential)[ \t]*[:=][ \t]*['"][^\s'"]{8,}['"]/gi,
+    /(authorization|bearer)[ \t]*[:=][ \t]*['"][^\s'"]{8,}['"]/gi,
+    /Bearer[ \t]+[0-9a-zA-Z._-]{8,}/g, // Authorization: Bearer <token> (unquoted)
+    /-----BEGIN\s+(RSA|DSA|EC|OPENSSH|PGP)\s+PRIVATE\s+KEY-----[\s\S]*?-----END\s+(RSA|DSA|EC|OPENSSH|PGP)\s+PRIVATE\s+KEY-----/g,
+    /(mysql|postgres|postgresql|mongodb|redis|amqp|mssql):\/\/[^\s'"]{8,}/gi,
+    /gh[pousr]_[0-9a-zA-Z]{36,}/g, // GitHub token
+    /glpat-[0-9a-zA-Z-]{20,}/g, // GitLab token
+    /xox[baprs]-[0-9a-zA-Z-]{10,}/g, // Slack token
+    /hooks\.slack\.com\/services\/T[0-9A-Z]{8,}\/B[0-9A-Z]{8,}\/[0-9a-zA-Z]{20,}/g,
+    /AIza[0-9A-Za-z_-]{35}/g, // Google API key
+    /[sr]k_(live|test)_[0-9a-zA-Z]{20,}/g, // Stripe key
+    /sk-(ant-)?[0-9a-zA-Z_-]{20,}/g, // OpenAI / Anthropic style key
+    /npm_[0-9a-zA-Z]{36,}/g, // npm token
+    /(secret|key|token|password)[ \t]*[:=][ \t]*['"]?[0-9a-f]{32,}['"]?/gi, // hex secret
+];
+/**
+ * Replace secret-shaped substrings in `text` with a placeholder, preserving the
+ * surrounding content. Pure and safe to call per log line. The placeholder
+ * contains no quote/brace/backslash, so redacting a JSON string keeps it valid.
+ */
+export function redactSecrets(text) {
+    let out = text;
+    for (const pattern of PATTERNS) {
+        out = out.replace(pattern, PLACEHOLDER);
+    }
+    return out;
+}

package/dist/resources/extensions/gsd/repo-identity.js

@@ -328,6 +328,22 @@ export function externalProjectsRoot() {
     const base = process.env.GSD_STATE_DIR || gsdHome();
     return join(base, "projects");
 }
+/**
+ * Check whether this project already has authoritative external state.
+ *
+ * Used by legacy `.gsd/` migration to avoid re-copying a re-materialized local
+ * directory over newer state when an already-migrated symlink was replaced.
+ */
+export function externalStateAlreadyExistsForProject(basePath) {
+    const base = process.env.GSD_STATE_DIR || gsdHome();
+    const computedPath = join(base, "projects", repoIdentity(basePath));
+    if (hasProjectState(computedPath))
+        return true;
+    const markerId = readGsdIdMarker(resolveGitRoot(basePath));
+    if (!markerId)
+        return false;
+    return hasProjectState(join(base, "projects", markerId));
+}
 // ─── Numbered Variant Cleanup ────────────────────────────────────────────────
 /**
  * macOS collision pattern: `.gsd 2`, `.gsd 3`, `.gsd 4`, etc.

package/dist/resources/extensions/gsd/repository-registry.js

@@ -5,6 +5,11 @@ import { isAbsolute, relative, resolve } from "node:path";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { resolveGsdPathContract } from "./paths.js";
 export function defaultRepositoryTargets(registry) {
+    // In parent mode, default to the declared child repositories so work is
+    // attributed to the repo it touches — not silently to the root "project".
+    if (registry.mode === "parent") {
+        return registry.repositories.filter((repo) => repo.id !== "project").map((repo) => repo.id);
+    }
     const project = registry.byId.get("project");
     if (project)
         return [project.id];
@@ -51,7 +56,7 @@ function resolveGitWorkingTreeRoot(basePath) {
 export function createRepositoryRegistry(basePath, workspacePrefs) {
     const contract = resolveGsdPathContract(basePath);
     const projectRoot = contract.isWorktree
-        ? resolveGitWorkingTreeRoot(contract.workRoot) ?? contract.projectRoot
+        ? resolveGitWorkingTreeRoot(contract.workRoot) ?? contract.workRoot
         : contract.projectRoot;
     const mode = workspacePrefs?.mode ?? "project";
     const repoMap = new Map();

package/dist/resources/extensions/gsd/root-write-leak-guard.js

@@ -42,12 +42,14 @@ export function captureRootDirtySnapshot(rootPath) {
         if (!line.trim())
             continue;
         const code = line.slice(0, 2);
+        if (code !== "??")
+            continue;
         const path = line.slice(3).replace(/^"|"$/g, "");
         if (!path || isRootRuntimePath(path))
             continue;
         snapshot.set(path, {
             path,
-            status: code.trim() || code,
+            status: code,
             fingerprint: fileFingerprint(rootPath, path),
         });
     }
@@ -58,7 +60,7 @@ export function detectRootWriteLeak(input) {
     const leaked = [];
     for (const entry of after.values()) {
         const prior = input.before?.get(entry.path);
-        if (!prior || prior.status !== entry.status || prior.fingerprint !== entry.fingerprint) {
+        if (!prior || prior.fingerprint !== entry.fingerprint) {
             leaked.push(entry);
         }
     }

package/dist/resources/extensions/gsd/safe-fs.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, cpSync } from "node:fs";
+import { existsSync, mkdirSync, cpSync, statSync } from "node:fs";
 import { dirname } from "node:path";
 import { logWarning } from "./workflow-logger.js";
 /**
@@ -40,7 +40,28 @@ export function safeCopyRecursive(src, dst, opts) {
         return false;
     try {
         mkdirSync(dirname(dst), { recursive: true });
-        cpSync(src, dst, { ...opts, recursive: true });
+        const userFilter = opts?.filter;
+        cpSync(src, dst, {
+            ...opts,
+            recursive: true,
+            filter: (srcPath, dstPath) => {
+                if (existsSync(dstPath)) {
+                    try {
+                        const srcStat = statSync(srcPath);
+                        const dstStat = statSync(dstPath);
+                        if (srcStat.isDirectory() !== dstStat.isDirectory()) {
+                            logWarning("fs", `recursive copy skipped type collision: ${srcPath} → ${dstPath}`);
+                            return false;
+                        }
+                    }
+                    catch (err) {
+                        logWarning("fs", `recursive copy skipped unreadable path: ${srcPath} → ${dstPath}: ${err.message}`);
+                        return false;
+                    }
+                }
+                return userFilter ? userFilter(srcPath, dstPath) : true;
+            },
+        });
         return true;
     }
     catch (err) {

package/dist/resources/extensions/gsd/skills/gsd-headless/SKILL.md

@@ -211,17 +211,15 @@ All state lives in `.gsd/` as markdown files (version-controllable):
 
 ```
 .gsd/
-  milestones/M001/
-    M001-CONTEXT.md      # Requirements, scope, decisions
-    M001-ROADMAP.md      # Slices with tasks, dependencies, checkboxes
-    M001-SUMMARY.md      # Completion summary
-    slices/S01/
-      S01-PLAN.md        # Task list
-      S01-SUMMARY.md     # Slice summary with frontmatter
-      tasks/T01-PLAN.md  # Individual task spec
+  phases/01-foundation/
+    01-CONTEXT.md        # Requirements, scope, decisions
+    01-ROADMAP.md        # Slices with tasks, dependencies, checkboxes
+    01-SUMMARY.md        # Completion summary
+    01-01-PLAN.md        # First slice task list
+    01-01-SUMMARY.md     # First slice summary with frontmatter
 ```
 
-State is derived from files on disk — checkboxes in ROADMAP.md are the source of truth for completion.
+Runtime state is stored in the project-root database; markdown files are reviewable projections written under `.gsd/phases/`. Legacy projects may still resolve to `.gsd/milestones/<MID>/` until migrated.
 
 ## All Headless Commands
 

package/dist/resources/extensions/gsd/skills/gsd-headless/references/commands.md

@@ -22,6 +22,7 @@ All commands can be run via `gsd headless [command]`.
 | `status` | Progress dashboard (TUI overlay — useful interactively, not for parsing) |
 | `visualize` | Workflow visualizer (deps, metrics, timeline) |
 | `history` | Execution history (supports --cost, --phase, --model, limit) |
+| `codebase` | Manage `.gsd/CODEBASE.md`; parent workspaces include declared child repositories under repo-labeled sections |
 
 ## Unit Control
 

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

@@ -12,6 +12,47 @@ import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
+import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "../repository-registry.js";
+function validateRepositoryTargetIds(field, value) {
+    const ids = validateStringArray(value, field);
+    if (ids.length === 0)
+        throw new Error(`${field} must include at least one repository id when provided`);
+    const deduped = Array.from(new Set(ids.map((id) => id.trim()).filter(Boolean)));
+    if (deduped.length === 0)
+        throw new Error(`${field} must include at least one repository id when provided`);
+    return deduped;
+}
+function validateReferencedRepositories(targetRepositories, registry) {
+    if (!targetRepositories)
+        return null;
+    const known = new Set(registry.repositories.map((repo) => repo.id));
+    const missing = targetRepositories.filter((id) => !known.has(id));
+    if (missing.length === 0)
+        return null;
+    return `unknown targetRepositories: ${missing.join(", ")}. Declared repositories: ${Array.from(known).join(", ")}`;
+}
+function resolveAllowedRootsForPathScope(targetRepositories, registry) {
+    if (targetRepositories.length === 0)
+        return [registry.projectRoot];
+    const roots = targetRepositories
+        .map((id) => registry.byId.get(id)?.root)
+        .filter((root) => typeof root === "string");
+    return roots.length > 0 ? roots : [registry.projectRoot];
+}
+function validatePathScopeForTargetRepositories(params, basePath, registry, targetRepositories) {
+    return validatePlanningPathScope(basePath, [
+        { field: "files", values: params.files },
+        { field: "inputs", values: params.inputs },
+        { field: "expectedOutput", values: params.expectedOutput },
+    ], resolveAllowedRootsForPathScope(targetRepositories, registry));
+}
+function resolveEffectiveTargetRepositories(taskTargetRepositories, sliceTargetRepositories, defaultTargets) {
+    if (taskTargetRepositories)
+        return taskTargetRepositories;
+    if (sliceTargetRepositories?.length)
+        return sliceTargetRepositories;
+    return defaultTargets;
+}
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -35,6 +76,9 @@ function validateParams(params) {
         files: validateStringArray(params.files, "files"),
         inputs: validateStringArray(params.inputs, "inputs"),
         expectedOutput: validateStringArray(params.expectedOutput, "expectedOutput"),
+        ...(params.targetRepositories !== undefined
+            ? { targetRepositories: validateRepositoryTargetIds("targetRepositories", params.targetRepositories) }
+            : {}),
     };
 }
 function resolveTaskGates(basePath) {
@@ -57,22 +101,18 @@ export async function handlePlanTask(rawParams, basePath) {
     if (pathOnlyError) {
         return { error: `validation failed: ${pathOnlyError}` };
     }
-    const pathScopeError = validatePlanningPathScope(basePath, [
-        { field: "files", values: params.files },
-        { field: "inputs", values: params.inputs },
-        { field: "expectedOutput", values: params.expectedOutput },
-    ]);
-    if (pathScopeError) {
-        return { error: `validation failed: ${pathScopeError}` };
-    }
     let taskGates;
+    let repositoryRegistry;
     try {
         taskGates = resolveTaskGates(basePath);
+        const loaded = loadEffectiveGSDPreferences(basePath);
+        repositoryRegistry = createRepositoryRegistryFromPreferences(basePath, loaded?.preferences);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { error: `validation failed: ${message}` };
     }
+    const defaultTargets = defaultRepositoryTargets(repositoryRegistry);
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     // Guards must be inside the transaction so the state they check cannot
     // change between the read and the write (#2723).
@@ -93,6 +133,33 @@ export async function handlePlanTask(rawParams, basePath) {
                 guardError = `cannot re-plan task ${params.taskId}: it is already complete — use gsd_task_reopen first`;
                 return;
             }
+            let effectiveTargetRepositories = resolveEffectiveTargetRepositories(params.targetRepositories, parentSlice.target_repositories, defaultTargets);
+            const repoValidationError = validateReferencedRepositories(effectiveTargetRepositories, repositoryRegistry);
+            if (repoValidationError) {
+                guardError = `validation failed: ${repoValidationError}`;
+                return;
+            }
+            let pathScopeError = validatePathScopeForTargetRepositories(params, basePath, repositoryRegistry, effectiveTargetRepositories);
+            const storedTaskTargets = existingTask?.target_repositories?.length
+                ? existingTask.target_repositories
+                : undefined;
+            // Omitted targetRepositories inherit the current slice default first.
+            // Fall back to the stored task target only when that inherited scope
+            // rejects the replan paths, preserving explicit per-task parent-root work.
+            if (pathScopeError && params.targetRepositories === undefined && storedTaskTargets) {
+                const storedRepoValidationError = validateReferencedRepositories(storedTaskTargets, repositoryRegistry);
+                const storedPathScopeError = storedRepoValidationError
+                    ? storedRepoValidationError
+                    : validatePathScopeForTargetRepositories(params, basePath, repositoryRegistry, storedTaskTargets);
+                if (!storedPathScopeError) {
+                    effectiveTargetRepositories = storedTaskTargets;
+                    pathScopeError = null;
+                }
+            }
+            if (pathScopeError) {
+                guardError = `validation failed: ${pathScopeError}`;
+                return;
+            }
             if (!existingTask) {
                 insertTask({
                     id: params.taskId,
@@ -112,6 +179,7 @@ export async function handlePlanTask(rawParams, basePath) {
                 expectedOutput: params.expectedOutput,
                 observabilityImpact: params.observabilityImpact ?? "",
                 fullPlanMd: params.fullPlanMd,
+                targetRepositories: effectiveTargetRepositories,
             });
             for (const gid of taskGates) {
                 insertGateRow({ milestoneId: params.milestoneId, sliceId: params.sliceId, gateId: gid, scope: "task", taskId: params.taskId });

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -29,7 +29,9 @@ import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { parseProject } from "../schemas/parsers.js";
 import { autoSession, getAutoRuntimeSnapshot, isAutoActive } from "../auto-runtime-state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
+import { readUnitHarnessAbort } from "../unit-runtime.js";
 import { prepareUatRun, saveUatAttemptArtifact, } from "../uat-run.js";
+import { appendNotification } from "../notification-store.js";
 import { registerAutoWorker, markWorkerStopping, getAutoWorker } from "../db/auto-workers.js";
 import { claimMilestoneLease, releaseMilestoneLease, getMilestoneLease, refreshMilestoneLease, milestoneLeaseTtlSeconds, } from "../db/milestone-leases.js";
 export const SUPPORTED_SUMMARY_ARTIFACT_TYPES = [
@@ -65,6 +67,35 @@ function blockIfWrongAutoUnit(requiredUnitType, operation) {
         isError: true,
     };
 }
+function blockIfHarnessAbortedUnit(operation, basePath) {
+    const snapshot = getAutoRuntimeSnapshot();
+    if (!snapshot.active || !snapshot.currentUnit)
+        return null;
+    const abort = readUnitHarnessAbort(snapshot.basePath || basePath, snapshot.currentUnit.type, snapshot.currentUnit.id, snapshot.currentUnit.startedAt);
+    if (!abort)
+        return null;
+    return harnessAbortResult(operation, snapshot.currentUnit.type, snapshot.currentUnit.id, abort);
+}
+function harnessAbortResult(operation, unitType, unitId, abort) {
+    const toolText = abort.toolName ? ` while calling ${abort.toolName}` : "";
+    const message = `Retryable harness abort: ${unitType} ${unitId} was truncated by ${abort.kind}${toolText}. ` +
+        "This gate result was not saved; leave the gate pending so auto-mode can rerun it.";
+    return {
+        content: [{ type: "text", text: message }],
+        details: {
+            operation,
+            error: "harness_aborted_needs_retry",
+            retryable: true,
+            unitType,
+            unitId,
+            harnessAbortKind: abort.kind,
+            harnessAbortReason: abort.reason,
+            harnessAbortToolName: abort.toolName,
+            harnessAbortCount: abort.count,
+        },
+        isError: true,
+    };
+}
 function milestoneLeaseConflictResult(milestoneId, byWorker, expiresAt) {
     return {
         content: [{ type: "text", text: `Milestone ${milestoneId} is currently leased by ${byWorker}. Retry after ${expiresAt}.` }],
@@ -959,6 +990,9 @@ export async function executeReassessRoadmap(params, basePath = process.cwd()) {
     }
 }
 export async function executeSaveGateResult(params, basePath = process.cwd()) {
+    const harnessAbort = blockIfHarnessAbortedUnit("save_gate_result", basePath);
+    if (harnessAbort)
+        return harnessAbort;
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable) {
         return {
@@ -1023,6 +1057,9 @@ export async function executeUatResultSave(params, basePath = process.cwd()) {
     const unitGuard = blockIfWrongAutoUnit("run-uat", "save_uat_result");
     if (unitGuard)
         return unitGuard;
+    const harnessAbort = blockIfHarnessAbortedUnit("save_uat_result", basePath);
+    if (harnessAbort)
+        return harnessAbort;
     const dbAvailable = await ensureDbOpen(basePath);
     if (!dbAvailable)
         return errorResult("save_uat_result", "GSD database is not available.", "db_unavailable");
@@ -1082,6 +1119,9 @@ export async function executeUatResultSave(params, basePath = process.cwd()) {
             evaluatedAt: run.evaluatedAt,
         });
         invalidateStateCache();
+        if (run.hasHuman) {
+            appendNotification(`UAT for ${run.params.milestoneId}/${run.params.sliceId} has NEEDS-HUMAN checks awaiting human validation`, "warning", "notify", { kind: "uat-needs-human", scope: `${run.params.milestoneId}/${run.params.sliceId}` });
+        }
         const savedText = `UAT result saved for ${run.params.milestoneId}/${run.params.sliceId}: ${run.params.verdict}`;
         return {
             content: [{

package/dist/resources/extensions/gsd/unit-context-manifest.js

@@ -178,9 +178,10 @@ export const UNIT_MANIFESTS = {
         codebaseMap: false,
         preferences: "active-only",
         contextMode: "verification",
-        // Validation may need to run shell verification commands and apply source
-        // fixes before milestone closeout can proceed.
-        tools: TOOLS_ALL,
+        // Validation must persist its durable output through gsd_validate_milestone;
+        // generic write/bash tools can create filesystem artifacts that bypass DB
+        // state and trigger destructive recovery loops.
+        tools: { mode: "workflow-only", allowedSubagents: ["reviewer", "security", "tester"] },
         artifacts: {
             inline: ["roadmap", "requirements", "templates"],
             excerpt: ["slice-summary", "slice-assessment"],
@@ -531,7 +532,7 @@ export function compileSubagentPermissionContract(policy) {
     if (policy.mode === "all") {
         return { allowed: true, allowedSubagents: ["*"], toolsMode: policy.mode };
     }
-    if ((policy.mode === "planning-dispatch" || policy.mode === "verification") &&
+    if ((policy.mode === "planning-dispatch" || policy.mode === "verification" || policy.mode === "workflow-only") &&
         Array.isArray(policy.allowedSubagents)) {
         return {
             allowed: policy.allowedSubagents.length > 0,