gsd-pi 2.82.0 → 3.0.0-dev.8b8d129d7

package/src/resources/extensions/gsd/git-service.ts

@@ -17,6 +17,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 {
@@ -123,6 +124,10 @@ export interface TurnGitActionResult {
   commitMessage?: string;
   snapshotLabel?: string;
   dirty?: boolean;
+  dirtyRepositories?: Record<string, boolean>;
+  commitMessages?: Record<string, string>;
+  commitErrors?: Record<string, string>;
+  skippedRepositories?: string[];
   error?: string;
 }
 
@@ -270,6 +275,30 @@ function isExcludedScopedPath(path: string, exclusions: readonly string[]): bool
   return false;
 }
 
+function submodulePathsFromLsFiles(output: string): Set<string> {
+  const submodulePaths = new Set<string>();
+  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: string, submodulePaths: ReadonlySet<string>): boolean {
+  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
@@ -364,6 +393,9 @@ export function readIntegrationBranch(basePath: string, milestoneId: string): st
   }
 }
 
+/** 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.
  *
@@ -374,14 +406,14 @@ export function readIntegrationBranch(basePath: string, milestoneId: string): st
  *
  * 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: string,
   milestoneId: string,
   branch: string,
 ): void {
+  // 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;
   // Don't record quick-task branches — they are ephemeral and merge back
@@ -764,6 +796,26 @@ export class GitServiceImpl {
       .filter(file => !nativeIsIgnored(this.basePath, file))
       .filter(file => !isExcludedScopedPath(file, allExclusions));
 
+    const scopedPaths: string[] = [];
+    const submodulePaths: string[] = [];
+    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
@@ -771,7 +823,7 @@ export class GitServiceImpl {
     // the whole commit fail (see #5500). Filter so valid paths still commit.
     const missing: string[] = [];
     const existing: string[] = [];
-    for (const path of normalized) {
+    for (const path of scopedPaths) {
       if (existsSync(join(this.basePath, path))) {
         existing.push(path);
       } else {
@@ -859,7 +911,19 @@ 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,
@@ -1153,28 +1217,97 @@ export function handleTurnGitActionError(action: TurnGitActionMode, err: unknown
   if (isInfrastructureError(err)) {
     throw err;
   }
+  const errorWithStreams = err as { stderr?: string; message?: string };
   return {
     action,
     status: "failed",
-    error: getErrorMessage(err),
+    error: errorWithStreams.stderr?.trim() || errorWithStreams.message || getErrorMessage(err),
   };
 }
 
+function collectRepositoryDirtyStatus(basePath: string): Record<string, boolean> {
+  const preferences = loadEffectiveGSDPreferences(basePath)?.preferences;
+  const registry = createRepositoryRegistryFromPreferences(basePath, preferences);
+  const dirtyByRepository: Record<string, boolean> = {};
+  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: {
+  basePath: string;
+  unitType: string;
+  unitId: string;
+  taskContext?: TaskCommitContext;
+  targetRepositories?: string[];
+}): {
+  commitMessages: Record<string, string>;
+  commitErrors: Record<string, string>;
+  skippedRepositories: string[];
+} {
+  const preferences = loadEffectiveGSDPreferences(args.basePath)?.preferences;
+  const registry = createRepositoryRegistryFromPreferences(args.basePath, preferences);
+  const repoIds = args.targetRepositories ?? ["project"];
+  const gitPrefs = preferences?.git ?? {};
+  const commitMessages: Record<string, string> = {};
+  const commitErrors: Record<string, string> = {};
+  const skippedRepositories: string[] = [];
+
+  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: {
   basePath: string;
   action: TurnGitActionMode;
   unitType: string;
   unitId: string;
   taskContext?: TaskCommitContext;
+  targetRepositories?: string[];
 }): TurnGitActionResult {
   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,
       };
     }
 
@@ -1186,16 +1319,38 @@ 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) {
     return handleTurnGitActionError(args.action, err);

package/src/resources/extensions/gsd/gsd-db.ts

@@ -81,6 +81,7 @@ import {
   applyMigrationV26MilestoneCommitAttributions,
   applyMigrationV27ArtifactHash,
   applyMigrationV28MemoryLastHitAt,
+  applyMigrationV29RepositoryTargets,
 } from "./db-migration-steps.js";
 import { isMemoriesFtsAvailableSchema, tryCreateMemoriesFtsSchema } from "./db-memory-fts-schema.js";
 import { createDbOpenState, type DbOpenPhase } from "./db-open-state.js";
@@ -109,15 +110,17 @@ const providerLoader = createSqliteProviderLoader({
   writeStderr: (message: string) => process.stderr.write(message),
 });
 
-export const SCHEMA_VERSION = 28;
+export const SCHEMA_VERSION = 29;
+const TERMINAL_STATUS_SQL = "'complete', 'done', 'skipped', 'closed'";
 
-function initSchema(db: DbAdapter, fileBacked: boolean): void {
-  if (fileBacked) db.exec("PRAGMA journal_mode=WAL");
+function initSchema(db: DbAdapter, fileBacked: boolean, dbPath: string | null): void {
+  const conservativeFilePragmas = fileBacked && _isLikelyWslDrvFsPathForTest(dbPath);
+  if (fileBacked) 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");
+  if (fileBacked) 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") db.exec("PRAGMA mmap_size = 67108864");  // 64 MB mmap
+  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");
 
@@ -156,6 +159,17 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
   migrateSchema(db);
 }
 
+export function _isLikelyWslDrvFsPathForTest(dbPath: string | null): boolean {
+  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
@@ -348,6 +362,11 @@ function migrateSchema(db: DbAdapter): void {
       recordSchemaVersion(db, 28);
     }
 
+    if (currentVersion < 29) {
+      applyMigrationV29RepositoryTargets(db);
+      recordSchemaVersion(db, 29);
+    }
+
     db.exec("COMMIT");
   } catch (err) {
     db.exec("ROLLBACK");
@@ -605,14 +624,14 @@ export function openDatabase(path: string): boolean {
   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.
     // Attempt VACUUM recovery before giving up (see #2519).
     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) {
         _dbOpenState.recordError("vacuum-recovery", retryErr);
@@ -962,6 +981,7 @@ export interface SlicePlanningRecord {
   proofLevel: string;
   integrationClosure: string;
   observabilityImpact: string;
+  targetRepositories?: string[];
 }
 
 export interface TaskPlanningRecord {
@@ -974,6 +994,7 @@ export interface TaskPlanningRecord {
   expectedOutput: string[];
   observabilityImpact: string;
   fullPlanMd?: string;
+  targetRepositories?: string[];
 }
 
 export function insertMilestone(m: {
@@ -1071,16 +1092,16 @@ export function insertSlice(s: {
   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,
@@ -1089,6 +1110,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`,
@@ -1106,6 +1128,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 ?? "",
@@ -1118,6 +1141,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
@@ -1157,7 +1181,8 @@ export function upsertSlicePlanning(milestoneId: string, sliceId: string, planni
       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,
@@ -1167,6 +1192,7 @@ export function upsertSlicePlanning(milestoneId: string, sliceId: string, planni
     ":proof_level": planning.proofLevel ?? null,
     ":integration_closure": planning.integrationClosure ?? null,
     ":observability_impact": planning.observabilityImpact ?? null,
+    ":target_repositories": planning.targetRepositories ? JSON.stringify(planning.targetRepositories) : null,
   });
 }
 
@@ -1196,11 +1222,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,
@@ -1223,7 +1251,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`,
+      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,
@@ -1249,6 +1281,11 @@ 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,
   });
 }
 
@@ -1285,7 +1322,8 @@ export function upsertTaskPlanning(milestoneId: string, sliceId: string, taskId:
       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,
@@ -1300,6 +1338,7 @@ export function upsertTaskPlanning(milestoneId: string, sliceId: string, taskId:
     ":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,
   });
 }
 
@@ -1603,7 +1642,7 @@ export function updateMilestoneStatus(milestoneId: string, status: string, compl
 export function getActiveMilestoneFromDb(): MilestoneRow | null {
   if (!currentDb) return null;
   const row = currentDb.prepare(
-    "SELECT * FROM milestones WHERE status NOT IN ('complete', 'parked') ORDER BY id LIMIT 1",
+    "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);
@@ -1659,7 +1698,7 @@ export function getArtifact(path: string): ArtifactRow | null {
 export function getActiveMilestoneIdFromDb(): IdStatusSummary | null {
   if (!currentDb) return null;
   const row = currentDb.prepare(
-    "SELECT id, status FROM milestones WHERE status NOT IN ('complete', 'parked') ORDER BY id LIMIT 1",
+    "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);
@@ -1788,12 +1827,14 @@ export function reconcileWorktreeDb(
       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();
@@ -1874,16 +1915,16 @@ export function reconcileWorktreeDb(
           )
           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,
@@ -1902,21 +1943,23 @@ export function reconcileWorktreeDb(
           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
@@ -1932,25 +1975,27 @@ export function reconcileWorktreeDb(
             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)"},
@@ -2081,6 +2126,9 @@ export function deleteTask(milestoneId: string, sliceId: string, taskId: string)
     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 });
@@ -2777,8 +2825,8 @@ export function restoreManifest(manifest: StateManifest): void {
       `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(
@@ -2786,6 +2834,7 @@ export function restoreManifest(manifest: StateManifest): void {
         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 ?? "",
@@ -2798,10 +2847,10 @@ export function restoreManifest(manifest: StateManifest): void {
         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(
@@ -2811,7 +2860,7 @@ export function restoreManifest(manifest: StateManifest): void {
         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.observability_impact, JSON.stringify(t.target_repositories ?? []), t.sequence,
         t.blocker_source ?? "",
         t.escalation_pending ?? 0,
         t.escalation_awaiting_review ?? 0,