gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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) {

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

@@ -37,7 +37,7 @@ import { rowToActiveDecision, rowToActiveRequirement, rowToDecision, rowToRequir
 import { rowToGate } from "./db-gate-rows.js";
 import { rowToArtifact, rowToMilestone } from "./db-milestone-artifact-rows.js";
 import { backupDatabaseBeforeMigration } from "./db-migration-backup.js";
-import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, applyMigrationV26MilestoneCommitAttributions, applyMigrationV27ArtifactHash, applyMigrationV28MemoryLastHitAt, } from "./db-migration-steps.js";
+import { applyMigrationV2Artifacts, applyMigrationV3Memories, applyMigrationV4DecisionMadeBy, applyMigrationV5HierarchyTables, applyMigrationV6SliceSummaries, applyMigrationV7Dependencies, applyMigrationV8PlanningFields, applyMigrationV9Ordering, applyMigrationV10ReplanTrigger, applyMigrationV11TaskPlanning, applyMigrationV12QualityGates, applyMigrationV13HotPathIndexes, applyMigrationV14SliceDependencies, applyMigrationV15AuditTables, applyMigrationV16EscalationSource, applyMigrationV17TaskEscalation, applyMigrationV18MemorySources, applyMigrationV19MemoryFts, applyMigrationV20MemoryRelations, applyMigrationV21StructuredMemories, applyMigrationV22QualityGateRepair, applyMigrationV23MilestoneQueue, applyMigrationV26MilestoneCommitAttributions, applyMigrationV27ArtifactHash, applyMigrationV28MemoryLastHitAt, applyMigrationV29RepositoryTargets, } from "./db-migration-steps.js";
 import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "./db-memory-fts-schema.js";
 import { createDbOpenState } from "./db-open-state.js";
 import { createRuntimeKvTableV25 } from "./db-runtime-kv-schema.js";
@@ -53,19 +53,21 @@ const providerLoader = createSqliteProviderLoader({
     nodeVersion: process.versions.node,
     writeStderr: (message) => process.stderr.write(message),
 });
-export const SCHEMA_VERSION = 28;
-function initSchema(db, fileBacked) {
+export const SCHEMA_VERSION = 29;
+const TERMINAL_STATUS_SQL = "'complete', 'done', 'skipped', 'closed'";
+function initSchema(db, fileBacked, dbPath) {
+    const conservativeFilePragmas = fileBacked && _isLikelyWslDrvFsPathForTest(dbPath);
     if (fileBacked)
-        db.exec("PRAGMA journal_mode=WAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA journal_mode=DELETE" : "PRAGMA journal_mode=WAL");
     if (fileBacked)
         db.exec("PRAGMA busy_timeout = 5000");
     if (fileBacked)
-        db.exec("PRAGMA synchronous = NORMAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA synchronous = FULL" : "PRAGMA synchronous = NORMAL");
     if (fileBacked)
         db.exec("PRAGMA auto_vacuum = INCREMENTAL");
     if (fileBacked)
         db.exec("PRAGMA cache_size = -8000"); // 8 MB page cache
-    if (fileBacked && process.platform !== "darwin")
+    if (fileBacked && !conservativeFilePragmas && process.platform !== "darwin")
         db.exec("PRAGMA mmap_size = 67108864"); // 64 MB mmap
     db.exec("PRAGMA temp_store = MEMORY");
     db.exec("PRAGMA foreign_keys = ON");
@@ -99,6 +101,19 @@ function initSchema(db, fileBacked) {
     }
     migrateSchema(db);
 }
+export function _isLikelyWslDrvFsPathForTest(dbPath) {
+    if (!dbPath || process.platform !== "linux")
+        return false;
+    const drvFsPathPattern = /^\/mnt\/[a-z](?:\/|$)/i;
+    if (drvFsPathPattern.test(dbPath))
+        return true;
+    try {
+        return drvFsPathPattern.test(realpathSync(dbPath));
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Create the FTS5 virtual table for memories plus the triggers that keep it
  * in sync with the base table. FTS5 may be unavailable on stripped-down
@@ -259,6 +274,10 @@ function migrateSchema(db) {
             applyMigrationV28MemoryLastHitAt(db);
             recordSchemaVersion(db, 28);
         }
+        if (currentVersion < 29) {
+            applyMigrationV29RepositoryTargets(db);
+            recordSchemaVersion(db, 29);
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -504,7 +523,7 @@ export function openDatabase(path) {
     const adapter = createDbAdapter(rawDb);
     const fileBacked = path !== ":memory:";
     try {
-        initSchema(adapter, fileBacked);
+        initSchema(adapter, fileBacked, path);
     }
     catch (err) {
         // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
@@ -512,7 +531,7 @@ export function openDatabase(path) {
         if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
             try {
                 adapter.exec("VACUUM");
-                initSchema(adapter, fileBacked);
+                initSchema(adapter, fileBacked, path);
                 process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
             }
             catch (retryErr) {
@@ -916,16 +935,16 @@ export function insertSlice(s) {
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`INSERT INTO slices (
       milestone_id, id, title, status, risk, depends, demo, created_at,
-      goal, success_criteria, proof_level, integration_closure, observability_impact, sequence,
+      goal, success_criteria, proof_level, integration_closure, observability_impact, target_repositories, sequence,
       is_sketch, sketch_scope
     ) VALUES (
       :milestone_id, :id, :title, :status, :risk, :depends, :demo, :created_at,
-      :goal, :success_criteria, :proof_level, :integration_closure, :observability_impact, :sequence,
+      :goal, :success_criteria, :proof_level, :integration_closure, :observability_impact, :target_repositories, :sequence,
       :is_sketch, :sketch_scope
     )
     ON CONFLICT (milestone_id, id) DO UPDATE SET
       title = CASE WHEN :raw_title IS NOT NULL THEN excluded.title ELSE slices.title END,
-      status = CASE WHEN slices.status IN ('complete', 'done') THEN slices.status ELSE excluded.status END,
+      status = CASE WHEN slices.status IN (${TERMINAL_STATUS_SQL}) THEN slices.status ELSE excluded.status END,
       risk = CASE WHEN :raw_risk IS NOT NULL THEN excluded.risk ELSE slices.risk END,
       depends = excluded.depends,
       demo = CASE WHEN :raw_demo IS NOT NULL THEN excluded.demo ELSE slices.demo END,
@@ -934,6 +953,7 @@ export function insertSlice(s) {
       proof_level = CASE WHEN :raw_proof_level IS NOT NULL THEN excluded.proof_level ELSE slices.proof_level END,
       integration_closure = CASE WHEN :raw_integration_closure IS NOT NULL THEN excluded.integration_closure ELSE slices.integration_closure END,
       observability_impact = CASE WHEN :raw_observability_impact IS NOT NULL THEN excluded.observability_impact ELSE slices.observability_impact END,
+      target_repositories = CASE WHEN :raw_target_repositories IS NOT NULL THEN excluded.target_repositories ELSE slices.target_repositories END,
       sequence = CASE WHEN :raw_sequence IS NOT NULL THEN excluded.sequence ELSE slices.sequence END,
       is_sketch = CASE WHEN :raw_is_sketch IS NOT NULL THEN excluded.is_sketch ELSE slices.is_sketch END,
       sketch_scope = CASE WHEN :raw_sketch_scope IS NOT NULL THEN excluded.sketch_scope ELSE slices.sketch_scope END`).run({
@@ -950,6 +970,7 @@ export function insertSlice(s) {
         ":proof_level": s.planning?.proofLevel ?? "",
         ":integration_closure": s.planning?.integrationClosure ?? "",
         ":observability_impact": s.planning?.observabilityImpact ?? "",
+        ":target_repositories": JSON.stringify(s.planning?.targetRepositories ?? []),
         ":sequence": s.sequence ?? 0,
         ":is_sketch": s.isSketch ? 1 : 0,
         ":sketch_scope": s.sketchScope ?? "",
@@ -962,6 +983,7 @@ export function insertSlice(s) {
         ":raw_proof_level": s.planning?.proofLevel ?? null,
         ":raw_integration_closure": s.planning?.integrationClosure ?? null,
         ":raw_observability_impact": s.planning?.observabilityImpact ?? null,
+        ":raw_target_repositories": s.planning?.targetRepositories ? JSON.stringify(s.planning.targetRepositories) : null,
         ":raw_sequence": s.sequence ?? null,
         ":raw_is_sketch": s.isSketch === undefined ? null : (s.isSketch ? 1 : 0),
         // NOTE: use !== undefined (not ??) so an explicit empty string "" is treated
@@ -996,7 +1018,8 @@ export function upsertSlicePlanning(milestoneId, sliceId, planning) {
       success_criteria = COALESCE(:success_criteria, success_criteria),
       proof_level = COALESCE(:proof_level, proof_level),
       integration_closure = COALESCE(:integration_closure, integration_closure),
-      observability_impact = COALESCE(:observability_impact, observability_impact)
+      observability_impact = COALESCE(:observability_impact, observability_impact),
+      target_repositories = COALESCE(:target_repositories, target_repositories)
      WHERE milestone_id = :milestone_id AND id = :id`).run({
         ":milestone_id": milestoneId,
         ":id": sliceId,
@@ -1005,6 +1028,7 @@ export function upsertSlicePlanning(milestoneId, sliceId, planning) {
         ":proof_level": planning.proofLevel ?? null,
         ":integration_closure": planning.integrationClosure ?? null,
         ":observability_impact": planning.observabilityImpact ?? null,
+        ":target_repositories": planning.targetRepositories ? JSON.stringify(planning.targetRepositories) : null,
     });
 }
 export function insertTask(t) {
@@ -1015,11 +1039,13 @@ export function insertTask(t) {
       verification_result, duration, completed_at, blocker_discovered,
       deviations, known_issues, key_files, key_decisions, full_summary_md,
       description, estimate, files, verify, inputs, expected_output, observability_impact, sequence
+      , target_repositories
     ) VALUES (
       :milestone_id, :slice_id, :id, :title, :status, :one_liner, :narrative,
       :verification_result, :duration, :completed_at, :blocker_discovered,
       :deviations, :known_issues, :key_files, :key_decisions, :full_summary_md,
       :description, :estimate, :files, :verify, :inputs, :expected_output, :observability_impact, :sequence
+      , :target_repositories
     )
     ON CONFLICT(milestone_id, slice_id, id) DO UPDATE SET
       title = CASE WHEN NULLIF(:title, '') IS NOT NULL THEN :title ELSE tasks.title END,
@@ -1042,7 +1068,11 @@ export function insertTask(t) {
       inputs = CASE WHEN NULLIF(:inputs, '[]') IS NOT NULL THEN :inputs ELSE tasks.inputs END,
       expected_output = CASE WHEN NULLIF(:expected_output, '[]') IS NOT NULL THEN :expected_output ELSE tasks.expected_output END,
       observability_impact = CASE WHEN NULLIF(:observability_impact, '') IS NOT NULL THEN :observability_impact ELSE tasks.observability_impact END,
-      sequence = :sequence`).run({
+      sequence = :sequence,
+      target_repositories = CASE
+        WHEN :raw_target_repositories IS NOT NULL THEN :target_repositories
+        ELSE tasks.target_repositories
+      END`).run({
         ":milestone_id": t.milestoneId,
         ":slice_id": t.sliceId,
         ":id": t.id,
@@ -1067,6 +1097,10 @@ export function insertTask(t) {
         ":expected_output": JSON.stringify(t.planning?.expectedOutput ?? []),
         ":observability_impact": t.planning?.observabilityImpact ?? "",
         ":sequence": t.sequence ?? 0,
+        ":target_repositories": JSON.stringify(t.planning?.targetRepositories ?? []),
+        ":raw_target_repositories": t.planning && "targetRepositories" in t.planning
+            ? JSON.stringify(t.planning.targetRepositories ?? [])
+            : null,
     });
 }
 export function updateTaskStatus(milestoneId, sliceId, taskId, status, completedAt) {
@@ -1098,7 +1132,8 @@ export function upsertTaskPlanning(milestoneId, sliceId, taskId, planning) {
       inputs = COALESCE(:inputs, inputs),
       expected_output = COALESCE(:expected_output, expected_output),
       observability_impact = COALESCE(:observability_impact, observability_impact),
-      full_plan_md = COALESCE(:full_plan_md, full_plan_md)
+      full_plan_md = COALESCE(:full_plan_md, full_plan_md),
+      target_repositories = COALESCE(:target_repositories, target_repositories)
      WHERE milestone_id = :milestone_id AND slice_id = :slice_id AND id = :id`).run({
         ":milestone_id": milestoneId,
         ":slice_id": sliceId,
@@ -1112,6 +1147,7 @@ export function upsertTaskPlanning(milestoneId, sliceId, taskId, planning) {
         ":expected_output": planning.expectedOutput ? JSON.stringify(planning.expectedOutput) : null,
         ":observability_impact": planning.observabilityImpact ?? null,
         ":full_plan_md": planning.fullPlanMd ?? null,
+        ":target_repositories": planning.targetRepositories ? JSON.stringify(planning.targetRepositories) : null,
     });
 }
 export function getSlice(milestoneId, sliceId) {
@@ -1352,7 +1388,7 @@ export function updateMilestoneStatus(milestoneId, status, completedAt) {
 export function getActiveMilestoneFromDb() {
     if (!currentDb)
         return null;
-    const row = currentDb.prepare("SELECT * FROM milestones WHERE status NOT IN ('complete', 'parked') ORDER BY id LIMIT 1").get();
+    const row = currentDb.prepare("SELECT * FROM milestones WHERE status NOT IN ('complete', 'done', 'skipped', 'closed', 'parked') ORDER BY id LIMIT 1").get();
     if (!row)
         return null;
     return rowToMilestone(row);
@@ -1404,7 +1440,7 @@ export function getArtifact(path) {
 export function getActiveMilestoneIdFromDb() {
     if (!currentDb)
         return null;
-    const row = currentDb.prepare("SELECT id, status FROM milestones WHERE status NOT IN ('complete', 'parked') ORDER BY id LIMIT 1").get();
+    const row = currentDb.prepare("SELECT id, status FROM milestones WHERE status NOT IN ('complete', 'done', 'skipped', 'closed', 'parked') ORDER BY id LIMIT 1").get();
     if (!row)
         return null;
     return rowToIdStatusSummary(row);
@@ -1510,12 +1546,14 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             const wtSliceInfo = adapter.prepare("PRAGMA wt.table_info('slices')").all();
             const hasIsSketch = wtSliceInfo.some((col) => col["name"] === "is_sketch");
             const hasSketchScope = wtSliceInfo.some((col) => col["name"] === "sketch_scope");
+            const hasSliceTargetRepositories = wtSliceInfo.some((col) => col["name"] === "target_repositories");
             const wtTaskInfo = adapter.prepare("PRAGMA wt.table_info('tasks')").all();
             const hasBlockerSource = wtTaskInfo.some((col) => col["name"] === "blocker_source");
             const hasEscalationPending = wtTaskInfo.some((col) => col["name"] === "escalation_pending");
             const hasEscalationAwaiting = wtTaskInfo.some((col) => col["name"] === "escalation_awaiting_review");
             const hasEscalationArtifact = wtTaskInfo.some((col) => col["name"] === "escalation_artifact_path");
             const hasEscalationOverride = wtTaskInfo.some((col) => col["name"] === "escalation_override_applied_at");
+            const hasTaskTargetRepositories = wtTaskInfo.some((col) => col["name"] === "target_repositories");
             const wtArtifactInfo = adapter.prepare("PRAGMA wt.table_info('artifacts')").all();
             const hasArtifactContentHash = wtArtifactInfo.some((col) => col["name"] === "content_hash");
             const wtMemoryInfo = adapter.prepare("PRAGMA wt.table_info('memories')").all();
@@ -1580,16 +1618,16 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
           )
           SELECT w.id, w.title,
                  CASE
-                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
                    THEN m.status ELSE w.status
                  END,
                  w.depends_on,
                  CASE
-                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
                    THEN m.created_at ELSE w.created_at
                  END,
                  CASE
-                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
                    THEN m.completed_at ELSE w.completed_at
                  END,
                  w.vision, w.success_criteria, w.key_risks, w.proof_strategy,
@@ -1607,21 +1645,23 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
           INSERT OR REPLACE INTO slices (
             milestone_id, id, title, status, risk, depends, demo, created_at, completed_at,
             full_summary_md, full_uat_md, goal, success_criteria, proof_level,
-            integration_closure, observability_impact, sequence, replan_triggered_at,
+            integration_closure, observability_impact, target_repositories, sequence, replan_triggered_at,
             is_sketch, sketch_scope
           )
           SELECT w.milestone_id, w.id, w.title,
                  CASE
-                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
                    THEN m.status ELSE w.status
                  END,
                  w.risk, w.depends, w.demo, w.created_at,
                  CASE
-                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
                    THEN m.completed_at ELSE w.completed_at
                  END,
                  w.full_summary_md, w.full_uat_md, w.goal, w.success_criteria, w.proof_level,
-                 w.integration_closure, w.observability_impact, w.sequence, w.replan_triggered_at,
+                 w.integration_closure, w.observability_impact,
+                 ${hasSliceTargetRepositories ? "w.target_repositories" : "COALESCE(m.target_repositories, '[]')"},
+                 w.sequence, w.replan_triggered_at,
                  ${hasIsSketch ? "w.is_sketch" : "COALESCE(m.is_sketch, 0)"},
                  ${hasSketchScope ? "w.sketch_scope" : "COALESCE(m.sketch_scope, '')"}
           FROM wt.slices w
@@ -1636,25 +1676,27 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             verification_result, duration, completed_at, blocker_discovered,
             deviations, known_issues, key_files, key_decisions, full_summary_md,
             description, estimate, files, verify, inputs, expected_output,
-            observability_impact, full_plan_md, sequence,
+            observability_impact, full_plan_md, target_repositories, sequence,
             blocker_source, escalation_pending, escalation_awaiting_review,
             escalation_artifact_path, escalation_override_applied_at
           )
           SELECT w.milestone_id, w.slice_id, w.id, w.title,
                  CASE
-                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
                    THEN m.status ELSE w.status
                  END,
                  w.one_liner, w.narrative,
                  w.verification_result, w.duration,
                  CASE
-                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   WHEN m.status IN (${TERMINAL_STATUS_SQL}) AND w.status NOT IN (${TERMINAL_STATUS_SQL})
                    THEN m.completed_at ELSE w.completed_at
                  END,
                  w.blocker_discovered,
                  w.deviations, w.known_issues, w.key_files, w.key_decisions, w.full_summary_md,
                  w.description, w.estimate, w.files, w.verify, w.inputs, w.expected_output,
-                 w.observability_impact, w.full_plan_md, w.sequence,
+                 w.observability_impact, w.full_plan_md,
+                 ${hasTaskTargetRepositories ? "w.target_repositories" : "COALESCE(m.target_repositories, '[]')"},
+                 w.sequence,
                  ${hasBlockerSource ? "w.blocker_source" : "COALESCE(m.blocker_source, '')"},
                  ${hasEscalationPending ? "w.escalation_pending" : "COALESCE(m.escalation_pending, 0)"},
                  ${hasEscalationAwaiting ? "w.escalation_awaiting_review" : "COALESCE(m.escalation_awaiting_review, 0)"},
@@ -1769,6 +1811,7 @@ export function deleteTask(milestoneId, sliceId, taskId) {
     transaction(() => {
         // Must delete verification_evidence first (FK constraint)
         currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+        currentDb.prepare(`DELETE FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
         currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
     });
 }
@@ -2266,22 +2309,22 @@ export function restoreManifest(manifest) {
         const slStmt = db.prepare(`INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo,
         created_at, completed_at, full_summary_md, full_uat_md,
         goal, success_criteria, proof_level, integration_closure, observability_impact,
-        sequence, replan_triggered_at, is_sketch, sketch_scope)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        target_repositories, sequence, replan_triggered_at, is_sketch, sketch_scope)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
         for (const s of manifest.slices) {
-            slStmt.run(s.milestone_id, s.id, s.title, s.status, s.risk, JSON.stringify(s.depends), s.demo, s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md, s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact, s.sequence, s.replan_triggered_at, s.is_sketch ?? 0, s.sketch_scope ?? "");
+            slStmt.run(s.milestone_id, s.id, s.title, s.status, s.risk, JSON.stringify(s.depends), s.demo, s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md, s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact, JSON.stringify(s.target_repositories ?? []), s.sequence, s.replan_triggered_at, s.is_sketch ?? 0, s.sketch_scope ?? "");
         }
         // Restore tasks (ADR-011 P2: includes blocker_source + escalation_* columns)
         const tkStmt = db.prepare(`INSERT INTO tasks (milestone_id, slice_id, id, title, status,
         one_liner, narrative, verification_result, duration, completed_at,
         blocker_discovered, deviations, known_issues, key_files, key_decisions,
         full_summary_md, description, estimate, files, verify,
-        inputs, expected_output, observability_impact, sequence,
+        inputs, expected_output, observability_impact, target_repositories, sequence,
         blocker_source, escalation_pending, escalation_awaiting_review,
         escalation_artifact_path, escalation_override_applied_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
         for (const t of manifest.tasks) {
-            tkStmt.run(t.milestone_id, t.slice_id, t.id, t.title, t.status, t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at, t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues, JSON.stringify(t.key_files), JSON.stringify(t.key_decisions), t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify, JSON.stringify(t.inputs), JSON.stringify(t.expected_output), t.observability_impact, t.sequence, t.blocker_source ?? "", t.escalation_pending ?? 0, t.escalation_awaiting_review ?? 0, t.escalation_artifact_path ?? null, t.escalation_override_applied_at ?? null);
+            tkStmt.run(t.milestone_id, t.slice_id, t.id, t.title, t.status, t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at, t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues, JSON.stringify(t.key_files), JSON.stringify(t.key_decisions), t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify, JSON.stringify(t.inputs), JSON.stringify(t.expected_output), t.observability_impact, JSON.stringify(t.target_repositories ?? []), t.sequence, t.blocker_source ?? "", t.escalation_pending ?? 0, t.escalation_awaiting_review ?? 0, t.escalation_artifact_path ?? null, t.escalation_override_applied_at ?? null);
         }
         // Restore decisions (ADR-011 P2: include source so escalation decisions survive)
         const dcStmt = db.prepare(`INSERT INTO decisions (seq, id, when_context, scope, decision, choice, rationale, revisable, made_by, source, superseded_by)