gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.1b44e695b

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

@@ -148,7 +148,9 @@ export async function handleForensics(args, ctx, pi) {
         dedupSection,
     });
     ctx.ui.notify(`Forensic report saved: ${relative(basePath, savedPath)}`, "info");
+    ctx.ui.setStatus("gsd-forensics", "running");
     pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
+    ctx.ui.setStatus("gsd-forensics", undefined);
     // Persist forensics context so follow-up turns can re-inject it (#2941)
     writeForensicsMarker(basePath, savedPath, content);
 }
@@ -172,6 +174,11 @@ export async function buildForensicReport(basePath) {
     const metrics = loadLedgerFromDisk(basePath);
     // 4. Load completed keys (legacy) and DB completion counts
     const completedKeys = loadCompletedKeys(basePath);
+    try {
+        const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+        await ensureDbOpen(basePath);
+    }
+    catch { /* best-effort DB open for report enrichment */ }
     const dbCompletionCounts = getDbCompletionCounts();
     // 5. Check crash lock
     const crashLock = readCrashLock(basePath);
@@ -677,7 +684,7 @@ export function detectWorktreeOrphans(summary, anomalies) {
             type: "worktree-unmerged-exit",
             severity: "warning",
             summary: `${summary.exitsWithUnmergedWork} auto-exit(s) left milestone work unmerged`,
-            details: `Exit reasons: ${reasonBreakdown || "(none)"} · Producer-side signal for #4761-class orphans. Inspect .gsd/journal/*.jsonl with eventType:"auto-exit" for per-exit detail.`,
+            details: `Exit reasons: ${reasonBreakdown || "(none)"} · Producer-side signal for orphaned worktrees. Inspect .gsd/journal/*.jsonl with eventType:"auto-exit" for per-exit detail.`,
         });
     }
 }
@@ -884,7 +891,7 @@ function saveForensicReport(basePath, report, problemDescription) {
                 .map(([r, n]) => `${r}=${n}`).join(", ");
             sections.push(`  - Exit reasons: ${breakdown}`);
         }
-        sections.push(`- Canonical-root redirects (#4761 fix fired): ${t.canonicalRedirects}`);
+        sections.push(`- Canonical-root redirects: ${t.canonicalRedirects}`);
         // #4765 slice-cadence counters
         if (t.slicesMerged + t.sliceMergeConflicts + t.milestoneResquashes > 0) {
             sections.push(`- Slices merged: ${t.slicesMerged} · Slice merge conflicts: ${t.sliceMergeConflicts}`);
@@ -1033,7 +1040,7 @@ function formatReportForPrompt(report) {
         if (hasSignal) {
             sections.push("### Worktree Telemetry");
             sections.push(`- Created: ${t.worktreesCreated} · Merged: ${t.worktreesMerged} · Conflicts: ${t.mergeConflicts}`);
-            sections.push(`- Orphans: ${t.orphansDetected} · Unmerged exits: ${t.exitsWithUnmergedWork} · Redirects (#4761): ${t.canonicalRedirects}`);
+            sections.push(`- Orphans: ${t.orphansDetected} · Unmerged exits: ${t.exitsWithUnmergedWork} · Redirects: ${t.canonicalRedirects}`);
             if (t.orphansDetected > 0) {
                 const breakdown = Object.entries(t.orphansByReason)
                     .map(([r, n]) => `${r}=${n}`).join(", ");

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

@@ -16,6 +16,7 @@ import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { logWarning } from "./workflow-logger.js";
+import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeAddPaths, nativeResetSoft, nativeCommitSubject, nativeIsIgnored, _resetHasChangesCache, } from "./native-git-bridge.js";
@@ -139,6 +140,30 @@ function isExcludedScopedPath(path, exclusions) {
     }
     return false;
 }
+function submodulePathsFromLsFiles(output) {
+    const submodulePaths = new Set();
+    if (!output)
+        return submodulePaths;
+    for (const line of output.split("\n")) {
+        const match = line.match(/^160000\s+\S+\s+\d+\t(.+)$/);
+        if (!match)
+            continue;
+        submodulePaths.add(match[1].replace(/\\/g, "/").replace(/\/+$/, ""));
+    }
+    return submodulePaths;
+}
+function isInsideSubmodule(path, submodulePaths) {
+    const normalizedPath = path.replace(/\\/g, "/");
+    if (submodulePaths.has(normalizedPath))
+        return true;
+    let slashIndex = normalizedPath.lastIndexOf("/");
+    while (slashIndex > 0) {
+        if (submodulePaths.has(normalizedPath.slice(0, slashIndex)))
+            return true;
+        slashIndex = normalizedPath.lastIndexOf("/", slashIndex - 1);
+    }
+    return false;
+}
 /**
  * Thrown when a slice merge hits code conflicts in non-.gsd files.
  * The working tree is left in a conflicted state (no reset) so the
@@ -213,6 +238,8 @@ export function readIntegrationBranch(basePath, milestoneId) {
         return null;
     }
 }
+/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
+export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 /**
  * Persist the integration branch for a milestone.
  *
@@ -223,9 +250,11 @@ export function readIntegrationBranch(basePath, milestoneId) {
  *
  * The file is committed immediately so the metadata is persisted in git.
  */
-/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
-export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 export function writeIntegrationBranch(basePath, milestoneId, branch) {
+    // Never persist milestone branches as integration targets.
+    // They are ephemeral execution branches and can cause self-diff corruption.
+    if (branch.startsWith("milestone/"))
+        return;
     // Don't record slice branches as the integration target
     if (SLICE_BRANCH_RE.test(branch))
         return;
@@ -262,6 +291,9 @@ export function writeIntegrationBranch(basePath, milestoneId, branch) {
     writeFileSync(metaFile, JSON.stringify(existing, null, 2) + "\n", "utf-8");
     // .gsd/ is managed externally (symlinked) — metadata is not committed to git.
 }
+function normalizeLocalBranchRef(branch) {
+    return branch.replace(/^refs\/heads\//, "");
+}
 /**
  * Resolve a milestone's recorded integration branch into an actionable status.
  *
@@ -280,7 +312,13 @@ export function resolveMilestoneIntegrationBranch(basePath, milestoneId, prefs =
             reason: `Milestone ${milestoneId} has no recorded integration branch metadata.`,
         };
     }
-    if (nativeBranchExists(basePath, recordedBranch)) {
+    const normalizedRecordedBranch = normalizeLocalBranchRef(recordedBranch);
+    const isRecordedMilestoneBranch = normalizedRecordedBranch.startsWith("milestone/");
+    const recordedBranchUsable = !isRecordedMilestoneBranch;
+    const recordedBranchStateMessage = isRecordedMilestoneBranch
+        ? `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} is invalid (milestone branches cannot be merge targets)`
+        : `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists`;
+    if (recordedBranchUsable && nativeBranchExists(basePath, recordedBranch)) {
         return {
             recordedBranch,
             effectiveBranch: recordedBranch,
@@ -297,14 +335,14 @@ export function resolveMilestoneIntegrationBranch(basePath, milestoneId, prefs =
                 recordedBranch,
                 effectiveBranch: configuredBranch,
                 status: "fallback",
-                reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists; using configured git.main_branch "${configuredBranch}" instead.`,
+                reason: `${recordedBranchStateMessage}; using configured git.main_branch "${configuredBranch}" instead.`,
             };
         }
         return {
             recordedBranch,
             effectiveBranch: null,
             status: "missing",
-            reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists, and configured git.main_branch "${configuredBranch}" is unavailable.`,
+            reason: `${recordedBranchStateMessage}, and configured git.main_branch "${configuredBranch}" is unavailable.`,
         };
     }
     try {
@@ -314,7 +352,7 @@ export function resolveMilestoneIntegrationBranch(basePath, milestoneId, prefs =
                 recordedBranch,
                 effectiveBranch: detectedBranch,
                 status: "fallback",
-                reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists; using detected fallback branch "${detectedBranch}" instead.`,
+                reason: `${recordedBranchStateMessage}; using detected fallback branch "${detectedBranch}" instead.`,
             };
         }
     }
@@ -325,7 +363,7 @@ export function resolveMilestoneIntegrationBranch(basePath, milestoneId, prefs =
         recordedBranch,
         effectiveBranch: null,
         status: "missing",
-        reason: `Recorded integration branch "${recordedBranch}" for milestone ${milestoneId} no longer exists, and no safe fallback branch could be determined.`,
+        reason: `${recordedBranchStateMessage}, and no safe fallback branch could be determined.`,
     };
 }
 // ─── Pre-Merge Command Tokenizer ──────────────────────────────────────────
@@ -572,6 +610,20 @@ export class GitServiceImpl {
             .filter((file) => file !== null)
             .filter(file => !nativeIsIgnored(this.basePath, file))
             .filter(file => !isExcludedScopedPath(file, allExclusions));
+        const scopedPaths = [];
+        const submodulePaths = [];
+        const repoSubmodules = submodulePathsFromLsFiles(runGit(this.basePath, ["ls-files", "--stage"], { allowFailure: true }));
+        for (const path of normalized) {
+            if (isInsideSubmodule(path, repoSubmodules)) {
+                submodulePaths.push(path);
+            }
+            else {
+                scopedPaths.push(path);
+            }
+        }
+        if (submodulePaths.length > 0) {
+            logWarning("engine", `scoped stage: dropping ${submodulePaths.length} keyFile(s) inside git submodule(s): ${submodulePaths.join(", ")}`, { file: "git-service.ts" });
+        }
         // Drop entries that don't exist on disk. The LLM occasionally lists files
         // it intended to write but didn't (or names them with wrong casing/path).
         // Pre-`b304f738b` `git add -A` swallowed these silently; the scoped
@@ -579,7 +631,7 @@ export class GitServiceImpl {
         // the whole commit fail (see #5500). Filter so valid paths still commit.
         const missing = [];
         const existing = [];
-        for (const path of normalized) {
+        for (const path of scopedPaths) {
             if (existsSync(join(this.basePath, path))) {
                 existing.push(path);
             }
@@ -651,7 +703,23 @@ export class GitServiceImpl {
         const message = taskContext
             ? buildTaskCommitMessage(taskContext)
             : `chore: auto-commit after ${unitType}\n\nGSD-Unit: ${unitId}`;
-        nativeCommit(this.basePath, message, { allowEmpty: false });
+        try {
+            nativeCommit(this.basePath, message, { allowEmpty: false });
+        }
+        catch (err) {
+            // Some pre-commit hooks intentionally rewrite files and fail the first
+            // commit to force a re-stage + retry.
+            if (!nativeHasChanges(this.basePath))
+                throw err;
+            const retriedScoped = taskContext
+                ? this.scopedStageTaskFiles(taskContext, extraExclusions)
+                : false;
+            if (!retriedScoped)
+                this.smartStage(extraExclusions);
+            if (!nativeHasStagedChanges(this.basePath))
+                throw err;
+            nativeCommit(this.basePath, message, { allowEmpty: false });
+        }
         // Absorb any preceding gsd snapshot commits into this real commit.
         // Walk backwards from HEAD~1 counting consecutive snapshot subjects,
         // then soft-reset to before them and re-commit with the same message.
@@ -919,21 +987,70 @@ export function handleTurnGitActionError(action, err) {
     if (isInfrastructureError(err)) {
         throw err;
     }
+    const errorWithStreams = err;
     return {
         action,
         status: "failed",
-        error: getErrorMessage(err),
+        error: errorWithStreams.stderr?.trim() || errorWithStreams.message || getErrorMessage(err),
     };
 }
+function collectRepositoryDirtyStatus(basePath) {
+    const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
+    const registry = createRepositoryRegistryFromPreferences(basePath, preferences);
+    const dirtyByRepository = {};
+    for (const repo of registry.repositories) {
+        try {
+            dirtyByRepository[repo.id] = runGit(repo.root, ["status", "--porcelain"]).length > 0;
+        }
+        catch {
+            // Fallback preserves legacy behavior if explicit status probing fails.
+            dirtyByRepository[repo.id] = nativeHasChanges(repo.root);
+        }
+    }
+    return dirtyByRepository;
+}
+function runPerRepositoryCommitAction(args) {
+    const preferences = loadEffectiveGSDPreferences(args.basePath)?.preferences;
+    const registry = createRepositoryRegistryFromPreferences(args.basePath, preferences);
+    const repoIds = args.targetRepositories ?? ["project"];
+    const gitPrefs = preferences?.git ?? {};
+    const commitMessages = {};
+    const commitErrors = {};
+    const skippedRepositories = [];
+    for (const repoId of repoIds) {
+        const repo = registry.byId.get(repoId);
+        if (!repo) {
+            commitErrors[repoId] = `unknown repository target: ${repoId}`;
+            continue;
+        }
+        if (repo.commitPolicy === "skip") {
+            skippedRepositories.push(repo.id);
+            continue;
+        }
+        try {
+            const message = new GitServiceImpl(repo.root, gitPrefs).autoCommit(args.unitType, args.unitId, [], args.taskContext) ?? "";
+            if (message) {
+                commitMessages[repo.id] = message;
+            }
+        }
+        catch (err) {
+            commitErrors[repo.id] = getErrorMessage(err);
+        }
+    }
+    return { commitMessages, commitErrors, skippedRepositories };
+}
 export function runTurnGitAction(args) {
     try {
         // Force fresh working-tree status per turn; nativeHasChanges caches briefly.
         _resetHasChangesCache();
+        const dirtyRepositories = collectRepositoryDirtyStatus(args.basePath);
+        const dirty = Object.values(dirtyRepositories).some(Boolean);
         if (args.action === "status-only") {
             return {
                 action: args.action,
                 status: "ok",
-                dirty: nativeHasChanges(args.basePath),
+                dirty,
+                dirtyRepositories,
             };
         }
         const git = createGitService(args.basePath);
@@ -944,15 +1061,35 @@ export function runTurnGitAction(args) {
                 action: args.action,
                 status: "ok",
                 snapshotLabel: label,
-                dirty: nativeHasChanges(args.basePath),
+                dirty,
+                dirtyRepositories,
+            };
+        }
+        const repoCommitResult = runPerRepositoryCommitAction(args);
+        if (Object.keys(repoCommitResult.commitErrors).length > 0) {
+            return {
+                action: args.action,
+                status: "failed",
+                error: Object.entries(repoCommitResult.commitErrors)
+                    .map(([repoId, msg]) => `${repoId}: ${msg}`)
+                    .join("; "),
+                dirty,
+                dirtyRepositories,
+                commitMessages: repoCommitResult.commitMessages,
+                commitErrors: repoCommitResult.commitErrors,
+                skippedRepositories: repoCommitResult.skippedRepositories,
             };
         }
-        const commitMessage = git.autoCommit(args.unitType, args.unitId, [], args.taskContext) ?? undefined;
+        const primaryMessage = repoCommitResult.commitMessages[args.targetRepositories?.[0] ?? "project"]
+            ?? Object.values(repoCommitResult.commitMessages)[0];
         return {
             action: args.action,
             status: "ok",
-            commitMessage,
-            dirty: nativeHasChanges(args.basePath),
+            commitMessage: primaryMessage,
+            dirty,
+            dirtyRepositories,
+            commitMessages: repoCommitResult.commitMessages,
+            skippedRepositories: repoCommitResult.skippedRepositories,
         };
     }
     catch (err) {