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

package/dist/resources/extensions/gsd/git-service.js

@@ -519,6 +519,51 @@ export function runGit(basePath, args, options = {}) {
         throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${filterGitSvnNoise(message)}`);
     }
 }
+/**
+ * Arguments for creating a task/workflow branch.
+ *
+ * When the current branch is a leftover GSD task branch (workflow template,
+ * quick task, or slice), the new branch starts from `baseBranch` — the
+ * caller's resolved integration branch, normally `GitServiceImpl.getMainBranch()`
+ * so `main_branch` preference, milestone integration branch, and worktree base
+ * all take priority over repo-default detection. Branching from HEAD there
+ * silently stacks consecutive workflow branches on top of each other, so every
+ * new gsd/* branch (and its eventual PR) drags along the previous workflow's
+ * commits.
+ *
+ * On any other branch (a user's feature branch, a worktree base, the main
+ * branch itself) the legacy branch-from-HEAD behavior is kept: basing new work
+ * on the branch the user chose to stand on is intentional there.
+ *
+ * Falls back to branch-from-HEAD, with a logged warning, when the base branch
+ * has no local ref or the working tree is still dirty (a start point that
+ * changes the tree would abort the checkout or strand in-flight changes).
+ * The base is the local ref — deliberately no fetch, so branch creation stays
+ * offline-safe even if the local base is behind its remote.
+ */
+export function taskBranchArgs(basePath, branchName, currentBranch, baseBranch) {
+    const args = ["checkout", "-b", branchName];
+    const onTaskBranch = WORKFLOW_BRANCH_RE.test(currentBranch) ||
+        QUICK_BRANCH_RE.test(currentBranch) ||
+        SLICE_BRANCH_RE.test(currentBranch);
+    if (!onTaskBranch || !baseBranch || baseBranch === currentBranch)
+        return args;
+    try {
+        if (!nativeBranchExists(basePath, baseBranch)) {
+            logWarning("engine", `taskBranchArgs: base branch "${baseBranch}" has no local ref — branching ${branchName} from HEAD (${currentBranch})`, { file: "git-service.ts" });
+            return args;
+        }
+        if (nativeHasChanges(basePath)) {
+            logWarning("engine", `taskBranchArgs: working tree still dirty after auto-commit — branching ${branchName} from HEAD (${currentBranch}) to preserve in-flight changes`, { file: "git-service.ts" });
+            return args;
+        }
+    }
+    catch {
+        return args;
+    }
+    args.push(baseBranch);
+    return args;
+}
 // ─── Commit Type Inference ─────────────────────────────────────────────────
 /**
  * Keyword-to-commit-type mapping. Order matters — first match wins.

package/dist/resources/extensions/gsd/gsd-db.js

@@ -1000,6 +1000,17 @@ export function deleteArtifactByPath(path) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     getDbOrNull().prepare("DELETE FROM artifacts WHERE path = :path").run({ ":path": path });
 }
+/** Delete artifact rows whose paths share a DB-relative prefix. */
+export function deleteArtifactsByPathPrefix(prefix) {
+    if (!getDbOrNull())
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    return transaction(() => {
+        const likePrefix = `${prefix}%`;
+        const countRow = getDbOrNull().prepare("SELECT COUNT(*) AS count FROM artifacts WHERE path LIKE :prefix").get({ ":prefix": likePrefix });
+        getDbOrNull().prepare("DELETE FROM artifacts WHERE path LIKE :prefix").run({ ":prefix": likePrefix });
+        return Number(countRow?.["count"] ?? 0);
+    });
+}
 /**
  * Drop hierarchy rows in dependency order inside a transaction. Used by
  * `gsd recover --confirm` to rebuild engine state from markdown.

package/dist/resources/extensions/gsd/guided-flow.js

@@ -28,7 +28,7 @@ import { nativeAddAll, nativeCommit, nativeHasCommittedHead, nativeIsRepo, nativ
 import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { getIsolationMode, loadEffectiveGSDPreferences } from "./preferences.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "./uok/plan-v2.js";
 import { detectProjectState, hasGsdBootstrapArtifacts } from "./detection.js";
@@ -50,7 +50,7 @@ import { getCachedWorkflowMcpProbe, probeAndCacheWorkflowMcp, warmWorkflowMcpPro
 import { probeCoversRequiredWorkflowTools } from "./tool-surface-readiness.js";
 import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
 import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
-import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "./tool-contract.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
 import { countPlanMilestoneRoadmapSlices } from "./artifact-verification.js";
@@ -491,7 +491,7 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType,
     const loadPreferences = resolvedOptions.deps?.loadPreferences ?? loadEffectiveGSDPreferences;
     const selectModel = resolvedOptions.deps?.selectModel ?? selectAndApplyModel;
     const getDispatchReadinessError = resolvedOptions.deps?.getDispatchReadinessError
-        ?? getUnitWorkflowDispatchReadinessError;
+        ?? getUnitWorkflowDispatchReadinessErrorForModel;
     // Route through the dynamic routing pipeline (complexity classification,
     // tier downgrade, fallback chains) — same path as auto-mode dispatches (#2958).
     if (ctx && unitType) {
@@ -506,16 +506,12 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType,
             });
         }
         const compatibilityError = getDispatchReadinessError({
-            provider: result.appliedModel?.provider ?? ctx.model?.provider,
+            model: result.appliedModel,
+            fallbackModel: ctx.model,
+            getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
             projectRoot,
             surface: "guided flow",
             unitType,
-            authMode: result.appliedModel?.provider
-                ? ctx.modelRegistry.getProviderAuthMode(result.appliedModel.provider)
-                : ctx.model?.provider
-                    ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
-                    : undefined,
-            baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
             // Guided flow starts the MCP workflow server as part of dispatch, so the
             // parent session's activeTools doesn't include MCP tools yet. The MCP
             // launch config check (detectWorkflowMcpLaunchConfig) is the right gate

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -1045,9 +1045,21 @@ export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanD
     return { replanPath: absPath, content };
 }
 export async function renderAssessmentFromDb(basePath, milestoneId, sliceId, assessmentData) {
-    // Flat-phase: assessment file lives in the phase dir
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
+    // Flat-phase: the assessment file lives in the phase dir, NOT in a slices/SID/
+    // subdir. resolveSlicePath() detects a slices/SID/ dir unconditionally, so a
+    // stray slices/SID/ created by an earlier planning step would send this write
+    // to a hybrid path (wrong dir, flat filename) that verification cannot find.
+    // Guard with the same legacy-base check relSlicePath() uses so flat-phase
+    // milestones always target the phase dir.
+    const mDir = resolveMilestonePath(basePath, milestoneId);
+    const legacyBase = legacyMilestonesDir(basePath);
+    const isLegacyLayout = mDir
+        ? mDir.startsWith(legacyBase + "/") || mDir.startsWith(legacyBase + "\\")
+        : false;
+    const fallbackDir = join(milestonesDir(basePath), canonicalPhaseDirName(milestoneId, getMilestone(milestoneId)?.title));
+    const slicePath = isLegacyLayout
+        ? (resolveSlicePath(basePath, milestoneId, sliceId) ?? fallbackDir)
+        : (mDir ?? fallbackDir);
     const phaseNum = milestoneIdToPhaseNum(milestoneId);
     const planNum = sliceIdToPlanNum(sliceId);
     const absPath = join(slicePath, planFileName(phaseNum, planNum, "ASSESSMENT"));

package/dist/resources/extensions/gsd/milestone-merge-transaction.js

@@ -1,5 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Process-level transaction wrapper for milestone merge closeout.
+import { mergeMilestoneToMain } from "./auto-worktree-merge.js";
 export function runMilestoneMergeTransaction(deps, input) {
     return deps.mergeMilestone(input.basePath, input.milestoneId, input.roadmapContent);
 }
@@ -8,3 +9,13 @@ export function createMilestoneMergeTransaction(mergeMilestone) {
         return runMilestoneMergeTransaction({ mergeMilestone }, { basePath, milestoneId, roadmapContent });
     };
 }
+/**
+ * Production merge transaction adapter.
+ *
+ * This is the only production construction point that knows the legacy
+ * `auto-worktree.ts` merge primitive. Lifecycle callers depend on the
+ * transaction runner interface, not the legacy implementation module.
+ */
+export function createDefaultMilestoneMergeTransaction(mergeMilestone = mergeMilestoneToMain) {
+    return createMilestoneMergeTransaction(mergeMilestone);
+}

package/dist/resources/extensions/gsd/milestone-settlement.js

@@ -1,6 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Milestone closeout settlement state across DB proof, artifacts, merge, and cleanup.
-import { isInAutoWorktree } from "./auto-worktree.js";
+import { isInAutoWorktree } from "./auto-worktree-entry.js";
 import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 import { resolveCloseoutArtifactProjection } from "./artifact-projection.js";
 function isActiveUnmergedWorktree(input) {

package/dist/resources/extensions/gsd/parallel-merge.js

@@ -8,7 +8,7 @@ import { existsSync, readdirSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { resolveGsdPathContract } from "./paths.js";
 import { worktreePathFor, worktreesDirs } from "./worktree-placement.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { buildWorktreeLifecycleDeps } from "./auto.js";
 import { mergeMilestoneStandalone, } from "./worktree-lifecycle.js";
 import { MergeConflictError } from "./git-service.js";

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -12,7 +12,9 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath } from "./worktree-manager.js";
-import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe, runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { autoWorktreeBranch, fastForwardReusedMilestoneBranchIfSafe } from "./auto-worktree-branch-lifecycle.js";
+import { syncGsdStateToWorktreeByScope } from "./auto-worktree-sync.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { nativeBranchExists } from "./native-git-bridge.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";

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

@@ -86,6 +86,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "min_request_interval_ms",
     "stale_commit_threshold_minutes",
     "context_management",
+    "tool_call_loop_guard",
     "experimental",
     "codebase",
     "slice_parallel",

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

@@ -801,6 +801,88 @@ export function validatePreferences(preferences) {
             errors.push("context_management must be an object");
         }
     }
+    // ─── Tool-call loop guard (#1198) ────────────────────────────────────────
+    if (preferences.tool_call_loop_guard !== undefined) {
+        if (typeof preferences.tool_call_loop_guard === "object" && preferences.tool_call_loop_guard !== null) {
+            const g = preferences.tool_call_loop_guard;
+            const validGuard = {};
+            if (g.enabled !== undefined) {
+                if (typeof g.enabled === "boolean")
+                    validGuard.enabled = g.enabled;
+                else
+                    errors.push("tool_call_loop_guard.enabled must be a boolean");
+            }
+            if (g.identical_args !== undefined) {
+                if (typeof g.identical_args === "object" && g.identical_args !== null) {
+                    const ia = g.identical_args;
+                    const validIa = {};
+                    if (ia.enabled !== undefined) {
+                        if (typeof ia.enabled === "boolean")
+                            validIa.enabled = ia.enabled;
+                        else
+                            errors.push("tool_call_loop_guard.identical_args.enabled must be a boolean");
+                    }
+                    if (ia.max_consecutive_calls !== undefined) {
+                        const n = ia.max_consecutive_calls;
+                        if (typeof n === "number" && Number.isInteger(n) && n >= 1)
+                            validIa.max_consecutive_calls = n;
+                        else
+                            errors.push("tool_call_loop_guard.identical_args.max_consecutive_calls must be an integer >= 1");
+                    }
+                    if (Object.keys(validIa).length > 0)
+                        validGuard.identical_args = validIa;
+                }
+                else {
+                    errors.push("tool_call_loop_guard.identical_args must be an object");
+                }
+            }
+            if (g.repeated_tool !== undefined) {
+                if (typeof g.repeated_tool === "object" && g.repeated_tool !== null) {
+                    const rt = g.repeated_tool;
+                    const validRt = {};
+                    if (rt.enabled !== undefined) {
+                        if (typeof rt.enabled === "boolean")
+                            validRt.enabled = rt.enabled;
+                        else
+                            errors.push("tool_call_loop_guard.repeated_tool.enabled must be a boolean");
+                    }
+                    if (rt.default_cap !== undefined) {
+                        const n = rt.default_cap;
+                        if (typeof n === "number" && Number.isInteger(n) && n >= 1)
+                            validRt.default_cap = n;
+                        else
+                            errors.push("tool_call_loop_guard.repeated_tool.default_cap must be an integer >= 1");
+                    }
+                    if (rt.repeatable_cap !== undefined) {
+                        const n = rt.repeatable_cap;
+                        if (typeof n === "number" && Number.isInteger(n) && n >= 1)
+                            validRt.repeatable_cap = n;
+                        else
+                            errors.push("tool_call_loop_guard.repeated_tool.repeatable_cap must be an integer >= 1");
+                    }
+                    if (rt.exempt_tools !== undefined) {
+                        if (Array.isArray(rt.exempt_tools) && rt.exempt_tools.every((t) => typeof t === "string")) {
+                            validRt.exempt_tools = rt.exempt_tools;
+                        }
+                        else {
+                            errors.push("tool_call_loop_guard.repeated_tool.exempt_tools must be an array of strings");
+                        }
+                    }
+                    if (Object.keys(validRt).length > 0)
+                        validGuard.repeated_tool = validRt;
+                }
+                else {
+                    errors.push("tool_call_loop_guard.repeated_tool must be an object");
+                }
+            }
+            if (Object.keys(validGuard).length > 0) {
+                validated.tool_call_loop_guard = validGuard;
+            }
+        }
+        else {
+            errors.push("tool_call_loop_guard must be an object");
+        }
+    }
     // ─── Context Mode (gsd_exec sandbox) ────────────────────────────────────
     if (preferences.context_mode !== undefined) {
         if (typeof preferences.context_mode === "object" && preferences.context_mode !== null) {

package/dist/resources/extensions/gsd/prompts/system.md

@@ -38,7 +38,7 @@ If a `GSD Skill Preferences` block appears below, treat it as durable guidance f
 
 ### Naming Convention
 
-Directories use bare IDs. Files use ID-SUFFIX format. Milestones: `M001/` or `M{seq}-{rand6}/` when `unique_milestone_ids: true`; files like `M001-CONTEXT.md`, `M001-ROADMAP.md`, `M001-RESEARCH.md`. Slices: `S01/` with `S01-PLAN.md`, `S01-RESEARCH.md`, `S01-SUMMARY.md`, `S01-UAT.md`. Tasks: `T01-PLAN.md`, `T01-SUMMARY.md`. Titles live inside content, not names.
+GSD projects use a flat-phase layout. Phase directories are `{MM}-{slug}` where `{MM}` is the zero-padded phase number and `{slug}` is derived from the phase title (e.g. `47-real-time-runtime-hardening`). Phase-level files are `{MM}-SUFFIX.md` (e.g. `47-CONTEXT.md`, `47-RESEARCH.md`, `47-ROADMAP.md`, `47-VALIDATION.md`, `47-SUMMARY.md`). Slice/plan files live directly in the phase directory as `{MM}-{SS}-SUFFIX.md` (e.g. `47-01-PLAN.md`, `47-01-SUMMARY.md`, `47-01-UAT.md`). Task plan content lives inside the slice plan file (`{MM}-{SS}-PLAN.md`) as checkboxes; there is no `tasks/` subdirectory and no `tasks/T##-PLAN.md`. Titles live inside content, not names. Prefer GSD-provided layout-aware paths/resolvers over hardcoding artifact paths, since phase slugs are title-derived.
 
 ### Directory Structure
 
@@ -46,13 +46,13 @@ Directories use bare IDs. Files use ID-SUFFIX format. Milestones: `M001/` or `M{
 .gsd/
   PROJECT.md, REQUIREMENTS.md, DECISIONS.md, KNOWLEDGE.md, CODEBASE.md, OVERRIDES.md, QUEUE.md, STATE.md
   runtime/, activity/, worktrees/
-  milestones/M001/
-    M001-CONTEXT.md, M001-RESEARCH.md, M001-ROADMAP.md, M001-SUMMARY.md
-    slices/S01/
-      S01-CONTEXT.md, S01-RESEARCH.md, S01-PLAN.md, S01-SUMMARY.md, S01-UAT.md
-      tasks/T01-PLAN.md, tasks/T01-SUMMARY.md
+  phases/{MM}-{slug}/
+    {MM}-CONTEXT.md, {MM}-RESEARCH.md, {MM}-ROADMAP.md, {MM}-VALIDATION.md, {MM}-SUMMARY.md
+    {MM}-{SS}-PLAN.md, {MM}-{SS}-SUMMARY.md, {MM}-{SS}-UAT.md
 ```
 
+Task plan content is embedded in `{MM}-{SS}-PLAN.md`; do not expect `tasks/T##-PLAN.md`.
+
 `runtime/`, `activity/`, `worktrees/`, and `STATE.md` are system-managed. `PROJECT.md` is current state; `REQUIREMENTS.md` is the active capability contract; `DECISIONS.md` and `KNOWLEDGE.md` are append-only; `CODEBASE.md` is an auto-refreshed codebase map.
 
 ### Isolation Model

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

@@ -13,7 +13,7 @@ import { isAbsolute, join, relative, resolve } from "node:path";
 import { QUICK_BRANCH_RE } from "./branch-patterns.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { GitServiceImpl, runGit } from "./git-service.js";
+import { GitServiceImpl, runGit, taskBranchArgs } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeBranchExists, nativeDetectMainBranch, nativeDiffNumstat } from "./native-git-bridge.js";
 import { nativeHasStagedChanges } from "./native-git-bridge.js";
@@ -317,6 +317,7 @@ export async function handleQuick(args, ctx, pi) {
     const git = new GitServiceImpl(basePath, gitPrefs);
     const branchName = `gsd/quick/${taskNum}-${slug}`;
     let originalBranch = git.getCurrentBranch();
+    let returnBranch = originalBranch;
     const { getIsolationMode } = await import("./preferences.js");
     const usesBranch = getIsolationMode() !== "none" && isGitOpsEnabled();
     let branchCreated = false;
@@ -331,7 +332,15 @@ export async function handleQuick(args, ctx, pi) {
                     }
                 }
                 catch { /* nothing to commit — fine */ }
-                runGit(basePath, ["checkout", "-b", branchName]);
+                const branchArgs = taskBranchArgs(basePath, branchName, current, git.getMainBranch());
+                const startPoint = branchArgs[3];
+                // When the quick branch is redirected off a stale task branch, the
+                // squash-merge on closeout must return to the same base — merging a
+                // base-branch-rooted quick branch back into the stale task branch
+                // would drag the base's newer history into it.
+                if (startPoint)
+                    returnBranch = startPoint;
+                runGit(basePath, branchArgs);
                 branchCreated = true;
             }
         }
@@ -345,7 +354,7 @@ export async function handleQuick(args, ctx, pi) {
     if (actualBranch === branchName && originalBranch !== branchName) {
         persistPendingReturn({
             basePath,
-            originalBranch,
+            originalBranch: returnBranch,
             quickBranch: branchName,
             taskNum,
             slug,

package/dist/resources/extensions/gsd/slice-parallel-orchestrator.js

@@ -19,7 +19,8 @@ import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
-import { runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { syncGsdStateToWorktreeByScope } from "./auto-worktree-sync.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { writeSessionStatus, } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";