@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.553dc518

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,

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

@@ -20,8 +20,9 @@
 //
 // Not yet declared here (remaining ADR-033 steps): the manifest data
 // (`UNIT_MANIFESTS` stays in unit-context-manifest.ts, already type-enforced
-// against the registry's `UnitType`) and prompt-template association (still
-// implicit in auto-prompts.ts builders).
+// against the registry's `UnitType`). Prompt-template association is declared
+// for direct one-template units and verified conditional template sets;
+// composition logic stays with prompt builders.
 import { BROWSER_CONTRACT_TOOL_NAMES } from "../shared/browser-contract.js";
 // ─── Shared tool-name constants (used by registry rows) ──────────────────
 export const RUN_UAT_WORKFLOW_TOOL_NAMES = [
@@ -50,6 +51,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
+        promptTemplate: "research-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_summary_save",
@@ -65,6 +67,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "plan-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -81,6 +84,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplates: ["discuss", "discuss-headless", "guided-discuss-milestone"],
         toolContract: {
             allowedGsdTools: [
                 "gsd_summary_save",
@@ -113,6 +117,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "section-close",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "validate-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -130,6 +135,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["completion"],
+        promptTemplate: "complete-milestone",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -153,6 +159,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
+        promptTemplate: "research-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -169,6 +176,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "plan-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -187,6 +195,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "refine-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -203,6 +212,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["planning"],
+        promptTemplate: "replan-slice",
         toolContract: {
             allowedGsdTools: ["gsd_replan_slice", "gsd_decision_save"],
             requiredWorkflowTools: ["gsd_replan_slice"],
@@ -212,6 +222,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "section-close",
         phaseChain: ["completion"],
+        promptTemplate: "complete-slice",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -246,6 +257,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "reassess-roadmap",
         toolContract: {
             allowedGsdTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
             requiredWorkflowTools: ["gsd_milestone_status", "gsd_reassess_roadmap"],
@@ -255,6 +267,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "execute-task",
         phaseChain: ["execution"],
+        promptTemplate: "execute-task",
         toolContract: {
             allowedGsdTools: [
                 "gsd_task_complete",
@@ -299,6 +312,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "execute-task",
         phaseChain: ["execution"],
+        promptTemplate: "reactive-execute",
         toolContract: {
             allowedGsdTools: [
                 "gsd_milestone_status",
@@ -314,6 +328,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["uat", "completion"],
+        promptTemplate: "run-uat",
         toolContract: {
             allowedGsdTools: [...RUN_UAT_WORKFLOW_TOOL_NAMES, "subagent"],
             requiredWorkflowTools: [...RUN_UAT_WORKFLOW_TOOL_NAMES],
@@ -328,6 +343,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "gate-evaluate",
         toolContract: {
             allowedGsdTools: ["gsd_save_gate_result"],
             requiredWorkflowTools: ["gsd_save_gate_result"],
@@ -337,6 +353,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["validation", "planning"],
+        promptTemplate: "rewrite-docs",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save", "gsd_decision_save"],
             requiredWorkflowTools: [],
@@ -361,6 +378,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-workflow-preferences",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save"],
             requiredWorkflowTools: [],
@@ -370,6 +388,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-discuss-project",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save", "gsd_decision_save", "gsd_requirement_save"],
             requiredWorkflowTools: ["ask_user_questions", "gsd_summary_save"],
@@ -379,6 +398,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-discuss-requirements",
         toolContract: {
             allowedGsdTools: ["gsd_requirement_save", "gsd_summary_save"],
             requiredWorkflowTools: ["ask_user_questions", "gsd_requirement_save", "gsd_summary_save"],
@@ -388,6 +408,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["discuss", "planning"],
+        promptTemplate: "guided-research-decision",
         toolContract: {
             allowedGsdTools: ["gsd_summary_save"],
             requiredWorkflowTools: ["ask_user_questions"],
@@ -400,6 +421,7 @@ export const UNIT_REGISTRY = {
         kind: "primary",
         scopeClass: "standard",
         phaseChain: ["research"],
+        promptTemplate: "guided-research-project",
         toolContract: {
             allowedGsdTools: [],
             requiredWorkflowTools: [],
@@ -419,3 +441,16 @@ export function getUnitDescriptor(unitType) {
 export function getUnitPhaseChain(unitType) {
     return getUnitDescriptor(unitType)?.phaseChain ?? null;
 }
+/** Prompt template id for units with a direct one-template builder. */
+export function getUnitPromptTemplate(unitType) {
+    return getUnitDescriptor(unitType)?.promptTemplate;
+}
+/** Prompt template ids for any verified direct or conditional prompt builder. */
+export function getUnitPromptTemplates(unitType) {
+    const descriptor = getUnitDescriptor(unitType);
+    if (!descriptor)
+        return [];
+    if (descriptor.promptTemplates)
+        return descriptor.promptTemplates;
+    return descriptor.promptTemplate ? [descriptor.promptTemplate] : [];
+}

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -93,6 +93,8 @@ export function writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, up
     const path = runtimePath(basePath, unitType, unitId);
     return withRecordLock(path, () => {
         const prev = readUnitRuntimeRecord(basePath, unitType, unitId);
+        const sameRun = prev?.startedAt === startedAt;
+        const updatesHarnessAbort = Object.prototype.hasOwnProperty.call(updates, "harnessAbort");
         const next = {
             version: 1,
             unitType,
@@ -109,11 +111,24 @@ export function writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, up
             recovery: updates.recovery ?? prev?.recovery,
             recoveryAttempts: updates.recoveryAttempts ?? prev?.recoveryAttempts ?? 0,
             lastRecoveryReason: updates.lastRecoveryReason ?? prev?.lastRecoveryReason,
+            harnessAbort: updatesHarnessAbort
+                ? updates.harnessAbort
+                : (sameRun ? prev?.harnessAbort : undefined),
         };
         atomicWriteSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
         return next;
     });
 }
+export function recordUnitHarnessAbort(basePath, unitType, unitId, startedAt, abort) {
+    return writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, {
+        harnessAbort: {
+            ...abort,
+            recordedAt: abort.recordedAt ?? Date.now(),
+        },
+        lastProgressAt: Date.now(),
+        lastProgressKind: `harness-abort:${abort.kind}`,
+    });
+}
 export function readUnitRuntimeRecord(basePath, unitType, unitId) {
     const path = runtimePath(basePath, unitType, unitId);
     if (!existsSync(path))
@@ -125,6 +140,12 @@ export function readUnitRuntimeRecord(basePath, unitType, unitId) {
         return null;
     }
 }
+export function readUnitHarnessAbort(basePath, unitType, unitId, startedAt) {
+    const record = readUnitRuntimeRecord(basePath, unitType, unitId);
+    if (!record || record.startedAt !== startedAt)
+        return null;
+    return record.harnessAbort ?? null;
+}
 export function clearUnitRuntimeRecord(basePath, unitType, unitId) {
     const path = runtimePath(basePath, unitType, unitId);
     if (existsSync(path))

package/dist/resources/extensions/gsd/unmerged-milestone-guard.js

@@ -2,7 +2,7 @@
 // File Purpose: Block new workflow entry when completed milestone branches are still unmerged.
 import { execFileSync } from "node:child_process";
 import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat, nativeIsAncestor, } from "./native-git-bridge.js";
-import { autoWorktreeBranch } from "./auto-worktree.js";
+import { autoWorktreeBranch } from "./auto-worktree-branch-lifecycle.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getAllMilestones } from "./gsd-db.js";
 import { resolveMilestoneIntegrationBranch } from "./git-service.js";

package/dist/resources/extensions/gsd/validation-block-guard.js

@@ -1,7 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Shared command gate for validation-blocked milestones.
 import { existsSync } from "node:fs";
-import { getAutoWorktreePath, isInAutoWorktree } from "./auto-worktree.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getIsolationMode } from "./preferences.js";

package/dist/resources/extensions/gsd/workspace-git-preflight.js

@@ -1,8 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Unified workspace git preflight probe, heal, and readiness checks.
 import { existsSync, realpathSync } from "node:fs";
-import { getAutoWorktreePath } from "./auto-worktree.js";
-import { isSafeToAutoResolve } from "./auto-worktree.js";
+import { isSafeToAutoResolve } from "./auto-worktree-conflict-auto-resolve.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { listMergeStateBlockers, probeGitConflictState, reconcileGitConflictsOnSignal, } from "./git-conflict-state.js";
 import { deriveState } from "./state.js";

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

@@ -1,10 +1,27 @@
 // gsd-pi + Workspace handle: single source of truth for path resolution per milestone
-import { join, resolve } from "node:path";
-import { resolveGsdPathContract, normalizeRealPath } from "./paths.js";
+import { dirname, join, resolve } from "node:path";
+import { buildMilestoneFileName, canonicalPhaseDirName, isLegacyMilestonesLayout, milestonesDir, resolveGsdPathContract, resolveMilestoneFile, resolveMilestonePath, normalizeRealPath, } from "./paths.js";
 import { isGsdWorktreePath, resolveWorktreeProjectRoot } from "./worktree-root.js";
 function tryRealpath(p) {
     return normalizeRealPath(p);
 }
+function isLegacyMilestoneDirectory(dir) {
+    const parent = dirname(dir);
+    return parent.endsWith("/milestones") || parent.endsWith("\\milestones");
+}
+function scopeMilestoneDir(basePath, milestoneId) {
+    return resolveMilestonePath(basePath, milestoneId) ?? join(milestonesDir(basePath), isLegacyMilestonesLayout(basePath) ? milestoneId : canonicalPhaseDirName(milestoneId));
+}
+function scopeMilestoneFile(basePath, milestoneId, suffix) {
+    const existing = resolveMilestoneFile(basePath, milestoneId, suffix);
+    if (existing)
+        return existing;
+    const dir = scopeMilestoneDir(basePath, milestoneId);
+    const filename = isLegacyMilestoneDirectory(dir)
+        ? `${milestoneId}-${suffix}.md`
+        : buildMilestoneFileName(milestoneId, suffix);
+    return join(dir, filename);
+}
 /**
  * Create an immutable GsdWorkspace handle from a raw base path.
  * Resolves both the project root and (when applicable) the worktree root,
@@ -39,21 +56,22 @@ export function createWorkspace(rawBasePath) {
  * Bind a milestoneId to a workspace, producing an immutable MilestoneScope
  * with path-returning closures for DB-authoritative project state.
  *
- * These scope paths intentionally route to contract.projectGsd. In-flight
- * markdown artifact readers outside this scope use the projection-aware
- * resolvers in paths.ts so worktree units can see worktree-local projections.
+ * DB paths route to contract.projectGsd. Milestone artifact paths resolve from
+ * the pinned project root with the layout-aware resolvers, so flat-phase and
+ * legacy projects use the same scope surface.
  */
 export function scopeMilestone(workspace, milestoneId) {
     const { contract } = workspace;
     const gsd = contract.projectGsd;
+    const basePath = workspace.projectRoot;
     const scope = Object.freeze({
         workspace,
         milestoneId,
-        contextFile: () => join(gsd, "milestones", milestoneId, `${milestoneId}-CONTEXT.md`),
-        roadmapFile: () => join(gsd, "milestones", milestoneId, `${milestoneId}-ROADMAP.md`),
+        contextFile: () => scopeMilestoneFile(basePath, milestoneId, "CONTEXT"),
+        roadmapFile: () => scopeMilestoneFile(basePath, milestoneId, "ROADMAP"),
         stateFile: () => join(gsd, "STATE.md"),
         dbPath: () => contract.projectDb,
-        milestoneDir: () => join(gsd, "milestones", milestoneId),
+        milestoneDir: () => scopeMilestoneDir(basePath, milestoneId),
         metaJson: () => join(gsd, `${milestoneId}-META.json`),
     });
     return scope;

package/dist/resources/extensions/gsd/worktree-command.js

@@ -11,7 +11,7 @@
  */
 import { loadPrompt } from "./prompt-loader.js";
 import { autoCommitCurrentBranch, getMainBranch, nudgeGitBranchCache } from "./worktree.js";
-import { runWorktreePostCreateHook } from "./auto-worktree.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { showConfirm } from "../shared/tui.js";
 import { gsdRoot, milestonesDir, resolveGsdPathContract } from "./paths.js";
 import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, getWorktreeGSDDiff, getWorktreeCodeDiff, getWorktreeLog, worktreeBranchName, worktreePath, } from "./worktree-manager.js";