gsd-pi 2.78.0 → 2.78.1-dev.2ff77b0ce

package/src/resources/extensions/gsd/schemas/validate.ts

@@ -0,0 +1,452 @@
+// gsd-2 / Deep planning mode — Artifact validator entry point.
+//
+// Validates PROJECT.md, REQUIREMENTS.md, and per-milestone ROADMAP.md
+// against the contract spec in .planning/phases/11-deep-planning-mode/11-CONTRACTS.md.
+// Used by deep-mode dispatch rules to gate stage completion and by light mode
+// auto-start to catch malformed artifacts early.
+
+import { existsSync, readFileSync } from "node:fs";
+import { parseProject, parseRequirements, parseRoadmap } from "./parsers.js";
+import type { ParsedRequirement } from "./parsers.js";
+
+export type ArtifactKind = "project" | "requirements" | "roadmap";
+
+export interface ValidationError {
+  code: string;
+  message: string;
+  location?: string;
+}
+
+export interface ValidationResult {
+  ok: boolean;
+  errors: ValidationError[];
+  warnings: ValidationError[];
+}
+
+export interface ValidateOptions {
+  /** Milestone ID (for example "M001") for the roadmap being validated. */
+  milestoneId?: string;
+  crossRefs?: {
+    projectPath?: string;
+    requirementsPath?: string;
+    /**
+     * Optional per-milestone roadmap paths. When supplied, requirement
+     * primaryOwner / supportingSlices entries are checked for slice-half
+     * (S##) existence in the named milestone's roadmap. Without this,
+     * only the milestone half (M###) is validated.
+     */
+    roadmapPaths?: Record<string, string>;
+  };
+}
+
+const REQUIRED_PROJECT_SECTIONS = [
+  "What This Is",
+  "Core Value",
+  "Current State",
+  "Architecture / Key Patterns",
+  "Capability Contract",
+  "Milestone Sequence",
+];
+
+const REQUIRED_REQUIREMENTS_SECTIONS = [
+  "Active",
+  "Validated",
+  "Deferred",
+  "Out of Scope",
+  "Traceability",
+  "Coverage Summary",
+];
+
+// Roadmap section requirements:
+//   - "Slices" (legacy H3 format) OR "Slice Overview" (table format
+//     emitted by workflow-projections.ts) — at least one must be present.
+//   - "Definition of Done" — always required.
+// Defensive parsing accepts both shapes; the validator does the same.
+const REQUIRED_ROADMAP_SECTIONS = ["Definition of Done"];
+const ROADMAP_SLICE_SECTIONS = ["Slices", "Slice Overview"];
+
+const ALLOWED_REQUIREMENT_CLASSES = new Set([
+  "core-capability",
+  "primary-user-loop",
+  "launchability",
+  "continuity",
+  "failure-visibility",
+  "integration",
+  "quality-attribute",
+  "operability",
+  "admin/support",
+  "compliance/security",
+  "differentiator",
+  "constraint",
+  "anti-feature",
+]);
+
+const STATUS_TO_SECTION: Record<string, string> = {
+  active: "Active",
+  validated: "Validated",
+  deferred: "Deferred",
+  "out-of-scope": "Out of Scope",
+};
+
+function loadFile(path: string): string | null {
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function err(code: string, message: string, location?: string): ValidationError {
+  return location ? { code, message, location } : { code, message };
+}
+
+// ─── PROJECT.md ─────────────────────────────────────────────────────────
+
+function validateProjectContent(content: string): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationError[] = [];
+  const parsed = parseProject(content);
+
+  for (const required of REQUIRED_PROJECT_SECTIONS) {
+    if (!(required in parsed.sections)) {
+      errors.push(err("missing-section", `Missing required section "## ${required}"`, required));
+    }
+  }
+
+  for (const sectionName of parsed.sectionsWithTokens) {
+    errors.push(err("template-token", `Section "${sectionName}" contains unsubstituted {{...}} template tokens`, sectionName));
+  }
+
+  for (const required of REQUIRED_PROJECT_SECTIONS) {
+    const body = parsed.sections[required];
+    if (body !== undefined && body.trim() === "") {
+      errors.push(err("empty-section", `Section "## ${required}" is empty`, required));
+    }
+  }
+
+  if (parsed.milestones.length === 0 && "Milestone Sequence" in parsed.sections) {
+    errors.push(err("no-milestones", "Milestone Sequence has no entries", "Milestone Sequence"));
+  }
+
+  const seen = new Set<string>();
+  let prevNum = 0;
+  for (const m of parsed.milestones) {
+    if (seen.has(m.id)) {
+      errors.push(err("duplicate-milestone", `Duplicate milestone ID ${m.id}`, "Milestone Sequence"));
+    }
+    seen.add(m.id);
+    const num = parseInt(m.id.slice(1), 10);
+    if (num !== prevNum + 1) {
+      warnings.push(err("non-monotonic-milestone", `Milestone ${m.id} is not monotonically numbered (expected M${String(prevNum + 1).padStart(3, "0")})`, "Milestone Sequence"));
+    }
+    prevNum = num;
+    if (!m.title || !m.oneLiner) {
+      errors.push(err("incomplete-milestone", `Milestone ${m.id} is missing title or one-liner`, "Milestone Sequence"));
+    }
+  }
+
+  const capabilityBody = parsed.sections["Capability Contract"] ?? "";
+  if (capabilityBody && !capabilityBody.includes("REQUIREMENTS.md")) {
+    warnings.push(err("missing-requirements-ref", "Capability Contract section should reference .gsd/REQUIREMENTS.md", "Capability Contract"));
+  }
+
+  return { ok: errors.length === 0, errors, warnings };
+}
+
+// ─── REQUIREMENTS.md ────────────────────────────────────────────────────
+
+function parseSliceList(raw: string): string[] {
+  // e.g. "M001/S02, M002/S03" or "—" or "none"
+  if (!raw) return [];
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed === "—" || trimmed === "-" || trimmed.toLowerCase() === "none") return [];
+  return trimmed.split(/[,\s]+/).map(s => s.trim()).filter(Boolean);
+}
+
+function validateRequirementsContent(
+  content: string,
+  projectContent: string | null,
+  roadmapsByMilestone: Map<string, ReturnType<typeof parseRoadmap>>,
+): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationError[] = [];
+  const parsed = parseRequirements(content);
+
+  for (const required of REQUIRED_REQUIREMENTS_SECTIONS) {
+    if (!(required in parsed.sections)) {
+      errors.push(err("missing-section", `Missing required section "## ${required}"`, required));
+    }
+  }
+
+  for (const sectionName of Object.keys(parsed.sections)) {
+    const body = parsed.sections[sectionName];
+    if (/\{\{[^}]+\}\}/.test(body)) {
+      errors.push(err("template-token", `Section "${sectionName}" contains unsubstituted {{...}} template tokens`, sectionName));
+    }
+  }
+
+  const seenIds = new Set<string>();
+  let prevNum = 0;
+  for (const r of parsed.requirements) {
+    if (seenIds.has(r.id)) {
+      errors.push(err("duplicate-requirement", `Duplicate requirement ID ${r.id}`, r.id));
+    }
+    seenIds.add(r.id);
+    const num = parseInt(r.id.slice(1), 10);
+    if (num <= prevNum) {
+      warnings.push(err("non-monotonic-requirement", `Requirement ${r.id} is not monotonically numbered`, r.id));
+    }
+    prevNum = num;
+    validateRequirementShape(r, errors, warnings);
+  }
+
+  const milestoneIds = projectContent
+    ? new Set(parseProject(projectContent).milestones.map(m => m.id))
+    : new Set(Array.from(roadmapsByMilestone.keys()));
+  const canValidateMilestones = projectContent !== null || roadmapsByMilestone.size > 0;
+
+  /**
+   * Validate one "M###/S##" reference (or partial). Pushes an error if
+   * the milestone is known to be missing; pushes an error if a roadmap is loaded
+   * for the milestone and the slice half is missing.
+   */
+  const checkRef = (
+    requirementId: string,
+    ref: string,
+    field: "primaryOwner" | "supportingSlices",
+  ): void => {
+    // Tolerate the documented "none yet" / "none" sentinels for primaryOwner.
+    if (field === "primaryOwner" && /^(none yet|none)$/.test(ref)) return;
+    // "M###" alone (no slash) is allowed for primaryOwner shape; still want
+    // to check milestone existence when project/roadmap context is available.
+    const milestoneOnly = ref.match(/^(M\d{3})$/);
+    if (milestoneOnly) {
+      if (canValidateMilestones && !milestoneIds.has(milestoneOnly[1])) {
+        errors.push(err("dangling-owner", `Requirement ${requirementId} ${field} references non-existent milestone ${milestoneOnly[1]}`, requirementId));
+      }
+      return;
+    }
+    const m = ref.match(/^(M\d{3})\/(S\d{2}|none yet)$/);
+    if (!m) {
+      warnings.push(err("malformed-slice-ref", `Requirement ${requirementId} ${field} value "${ref}" does not match expected M###/S## format`, requirementId));
+      return;
+    }
+    const [, milestoneId, sliceHalf] = m;
+    if (canValidateMilestones && !milestoneIds.has(milestoneId)) {
+      errors.push(err("dangling-owner", `Requirement ${requirementId} ${field} references non-existent milestone ${milestoneId}`, requirementId));
+      return;
+    }
+    // Slice-half cross-ref: only enforced when we have a roadmap for the milestone.
+    if (sliceHalf === "none yet") return;
+    const roadmap = roadmapsByMilestone.get(milestoneId);
+    if (!roadmap) return;
+    const sliceExists = roadmap.slices.some(s => s.id === sliceHalf);
+    if (!sliceExists) {
+      errors.push(err(
+        "dangling-slice-ref",
+        `Requirement ${requirementId} ${field} references slice ${milestoneId}/${sliceHalf} which does not exist in that milestone's roadmap`,
+        requirementId,
+      ));
+    }
+  };
+
+  for (const r of parsed.requirements) {
+    // primaryOwner: single reference.
+    if (r.primaryOwner) checkRef(r.id, r.primaryOwner, "primaryOwner");
+    // supportingSlices: comma/space-separated list.
+    for (const ref of parseSliceList(r.supportingSlices)) {
+      checkRef(r.id, ref, "supportingSlices");
+    }
+  }
+
+  const sectionCounts: Record<string, number> = { Active: 0, Validated: 0, Deferred: 0, "Out of Scope": 0 };
+  for (const r of parsed.requirements) sectionCounts[r.parentSection] = (sectionCounts[r.parentSection] ?? 0) + 1;
+
+  const expectedActive = sectionCounts.Active;
+  const reportedActive = parsed.coverageSummary["Active requirements"];
+  if (reportedActive !== undefined && parseInt(reportedActive, 10) !== expectedActive) {
+    warnings.push(err("coverage-mismatch", `Coverage Summary says Active=${reportedActive} but ${expectedActive} entries found in ## Active`, "Coverage Summary"));
+  }
+
+  return { ok: errors.length === 0, errors, warnings };
+}
+
+function validateRequirementShape(r: ParsedRequirement, errors: ValidationError[], warnings: ValidationError[]): void {
+  const required: Array<keyof ParsedRequirement> = [
+    "class", "status", "description", "whyItMatters", "source", "primaryOwner", "validation",
+  ];
+  for (const field of required) {
+    if (!r[field] || (r[field] as string).trim() === "") {
+      errors.push(err("missing-field", `Requirement ${r.id} is missing field "${field}"`, r.id));
+    }
+  }
+
+  if (r.class && !ALLOWED_REQUIREMENT_CLASSES.has(r.class)) {
+    errors.push(err("invalid-class", `Requirement ${r.id} has invalid class "${r.class}"`, r.id));
+  }
+
+  const expectedSection = STATUS_TO_SECTION[r.status];
+  if (expectedSection && expectedSection !== r.parentSection) {
+    errors.push(err("status-section-mismatch", `Requirement ${r.id} has Status "${r.status}" but lives under "## ${r.parentSection}" (expected "## ${expectedSection}")`, r.id));
+  }
+
+  if (r.primaryOwner && !/^(M\d{3}(\/(S\d{2}|none yet))?|none yet|none)$/.test(r.primaryOwner)) {
+    warnings.push(err("malformed-owner", `Requirement ${r.id} owner "${r.primaryOwner}" does not match expected formats (M### | M###/S## | M###/none yet | none yet | none)`, r.id));
+  }
+}
+
+// ─── ROADMAP.md ─────────────────────────────────────────────────────────
+
+function validateRoadmapContent(content: string, requirementsContent: string | null, currentMilestoneId: string | null = null): ValidationResult {
+  const errors: ValidationError[] = [];
+  const warnings: ValidationError[] = [];
+  const parsed = parseRoadmap(content);
+
+  for (const required of REQUIRED_ROADMAP_SECTIONS) {
+    if (!(required in parsed.sections)) {
+      errors.push(err("missing-section", `Missing required section "## ${required}"`, required));
+    }
+  }
+  // Slice section: accept either "## Slices" or "## Slice Overview".
+  const hasSliceSection = ROADMAP_SLICE_SECTIONS.some(name => name in parsed.sections);
+  if (!hasSliceSection) {
+    errors.push(err("missing-section", `Missing slice section — expected "## Slices" or "## Slice Overview"`));
+  }
+
+  for (const sectionName of Object.keys(parsed.sections)) {
+    const body = parsed.sections[sectionName];
+    if (/\{\{[^}]+\}\}/.test(body)) {
+      errors.push(err("template-token", `Section "${sectionName}" contains unsubstituted {{...}} template tokens`, sectionName));
+    }
+  }
+
+  if (parsed.slices.length === 0 && hasSliceSection) {
+    const sliceSection = ROADMAP_SLICE_SECTIONS.find(name => name in parsed.sections) ?? "Slices";
+    errors.push(err("no-slices", `${sliceSection} section has no entries`, sliceSection));
+  }
+
+  // I5: surface malformed Depends tokens (e.g. "S99;" or "S01-S03") that the
+  // parser dropped from the dependency graph. Warning, not error — the rest
+  // of the graph is still usable.
+  for (const m of parsed.malformedDepends) {
+    warnings.push(err(
+      "malformed-depends",
+      `Slice ${m.sliceId} has malformed Depends value(s) that were dropped from the graph: ${m.values.join(", ")}`,
+      m.sliceId,
+    ));
+  }
+
+  if (parsed.definitionOfDone.length === 0 && "Definition of Done" in parsed.sections) {
+    errors.push(err("no-definition-of-done", "Definition of Done has no items", "Definition of Done"));
+  }
+
+  const seenIds = new Set<string>();
+  let prevNum = 0;
+  for (const s of parsed.slices) {
+    if (seenIds.has(s.id)) {
+      errors.push(err("duplicate-slice", `Duplicate slice ID ${s.id}`, s.id));
+    }
+    seenIds.add(s.id);
+    const num = parseInt(s.id.slice(1), 10);
+    if (num !== prevNum + 1) {
+      warnings.push(err("non-monotonic-slice", `Slice ${s.id} is not monotonically numbered (expected S${String(prevNum + 1).padStart(2, "0")})`, s.id));
+    }
+    prevNum = num;
+    if (!s.risk || !s.demo) {
+      errors.push(err("missing-slice-field", `Slice ${s.id} is missing required field (risk and demo are required)`, s.id));
+    }
+  }
+
+  // Depends graph: dangling refs + cycle detection
+  const sliceIds = new Set(parsed.slices.map(s => s.id));
+  for (const s of parsed.slices) {
+    for (const dep of s.depends) {
+      if (!sliceIds.has(dep)) {
+        errors.push(err("dangling-dependency", `Slice ${s.id} depends on non-existent slice ${dep}`, s.id));
+      }
+    }
+  }
+  if (hasCycle(parsed.slices)) {
+    errors.push(err("circular-dependency", "Slice depends graph contains a cycle"));
+  }
+
+  if (requirementsContent) {
+    const reqs = parseRequirements(requirementsContent);
+    for (const s of parsed.slices) {
+      const ownsAnyRequirement = reqs.requirements.some(r => {
+        if (r.parentSection !== "Active") return false;
+        const m = r.primaryOwner.match(/^(M\d{3})\/(S\d{2})$/);
+        if (!m) return false;
+        if (currentMilestoneId !== null && m[1] !== currentMilestoneId) return false;
+        return m[2] === s.id;
+      });
+      if (!ownsAnyRequirement) {
+        warnings.push(err("orphan-slice", `Slice ${s.id} owns no Active requirements`, s.id));
+      }
+    }
+  }
+
+  return { ok: errors.length === 0, errors, warnings };
+}
+
+function hasCycle(slices: Array<{ id: string; depends: string[] }>): boolean {
+  const map = new Map(slices.map(s => [s.id, s.depends]));
+  const visiting = new Set<string>();
+  const visited = new Set<string>();
+
+  function dfs(id: string): boolean {
+    if (visiting.has(id)) return true;
+    if (visited.has(id)) return false;
+    visiting.add(id);
+    for (const dep of map.get(id) ?? []) {
+      if (dfs(dep)) return true;
+    }
+    visiting.delete(id);
+    visited.add(id);
+    return false;
+  }
+
+  for (const s of slices) {
+    if (dfs(s.id)) return true;
+  }
+  return false;
+}
+
+// ─── Entry point ────────────────────────────────────────────────────────
+
+export function validateArtifact(
+  filePath: string,
+  kind: ArtifactKind,
+  opts: ValidateOptions = {},
+): ValidationResult {
+  const content = loadFile(filePath);
+  if (content === null) {
+    return {
+      ok: false,
+      errors: [err("file-missing", `Artifact file not found: ${filePath}`, filePath)],
+      warnings: [],
+    };
+  }
+
+  switch (kind) {
+    case "project":
+      return validateProjectContent(content);
+    case "requirements": {
+      const projectContent = opts.crossRefs?.projectPath ? loadFile(opts.crossRefs.projectPath) : null;
+      const roadmapsByMilestone = new Map<string, ReturnType<typeof parseRoadmap>>();
+      const roadmapPaths = opts.crossRefs?.roadmapPaths ?? {};
+      for (const [mid, path] of Object.entries(roadmapPaths)) {
+        const c = loadFile(path);
+        if (c) roadmapsByMilestone.set(mid, parseRoadmap(c));
+      }
+      return validateRequirementsContent(content, projectContent, roadmapsByMilestone);
+    }
+    case "roadmap":
+      return validateRoadmapContent(
+        content,
+        opts.crossRefs?.requirementsPath ? loadFile(opts.crossRefs.requirementsPath) : null,
+        opts.milestoneId ?? filePath.match(/(?:^|[\\/])(M\d{3})(?:[\\/]|-)/)?.[1] ?? null,
+      );
+  }
+}

package/src/resources/extensions/gsd/skill-telemetry.ts

@@ -13,6 +13,7 @@
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { gsdHome } from "./gsd-home.js";
 import { homedir } from "node:os";
 
 // ─── In-memory state ──────────────────────────────────────────────────────────
@@ -32,7 +33,7 @@ const activelyLoadedSkills = new Set<string>();
 export function captureAvailableSkills(): void {
   const skillsDir = join(homedir(), ".agents", "skills");
   const claudeSkillsDir = join(homedir(), ".claude", "skills");
-  const legacyDir = join(homedir(), ".gsd", "agent", "skills");
+  const legacyDir = join(gsdHome(), "agent", "skills");
   const names = listSkillNames(skillsDir);
   const claudeNames = listSkillNames(claudeSkillsDir);
   // Include skills still in the legacy directory only if migration hasn't completed
@@ -109,7 +110,7 @@ export function detectStaleSkills(
   // Check all installed skills, not just those with usage data
   const skillsDir = join(homedir(), ".agents", "skills");
   const claudeSkillsDir = join(homedir(), ".claude", "skills");
-  const legacyDir = join(homedir(), ".gsd", "agent", "skills");
+  const legacyDir = join(gsdHome(), "agent", "skills");
   const legacyMigrated = existsSync(join(legacyDir, ".migrated-to-agents"));
   const legacyNames = legacyMigrated ? [] : listSkillNames(legacyDir);
   const installedSet = new Set([...listSkillNames(skillsDir), ...listSkillNames(claudeSkillsDir), ...legacyNames]);

package/src/resources/extensions/gsd/slice-cadence.ts

@@ -24,9 +24,10 @@ import { join } from "node:path";
 import { execFileSync } from "node:child_process";
 
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
-import { MergeConflictError } from "./git-service.js";
+import { MergeConflictError, readIntegrationBranch } from "./git-service.js";
 import {
   nativeBranchForceReset,
+  nativeBranchExists,
   nativeCheckoutBranch,
   nativeCommit,
   nativeCommitCountBetween,
@@ -37,6 +38,8 @@ import {
 import { resolveGitDir } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { emitSliceMerged, emitMilestoneResquash } from "./worktree-telemetry.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 
 /**
  * Auto-worktree milestone branch name. Must match autoWorktreeBranch() in
@@ -46,6 +49,17 @@ function milestoneBranchName(milestoneId: string): string {
   return `milestone/${milestoneId}`;
 }
 
+function resolveIntegrationBranch(projectRoot: string, milestoneId: string): string {
+  const recorded = readIntegrationBranch(projectRoot, milestoneId);
+  if (recorded && nativeBranchExists(projectRoot, recorded)) return recorded;
+
+  const prefs = loadEffectiveGSDPreferences(projectRoot)?.preferences?.git ?? {};
+  const configured = prefs.main_branch;
+  if (configured && nativeBranchExists(projectRoot, configured)) return configured;
+
+  return nativeDetectMainBranch(projectRoot);
+}
+
 function cleanupMergeArtifacts(projectRoot: string): void {
   try {
     const gitDir = resolveGitDir(projectRoot);
@@ -58,6 +72,49 @@ function cleanupMergeArtifacts(projectRoot: string): void {
   }
 }
 
+function advanceMilestoneBranch(
+  projectRoot: string,
+  worktreeCwd: string,
+  milestoneBranch: string,
+  mainBranch: string,
+): void {
+  let worktreeBranch: string | null = null;
+  try {
+    worktreeBranch = execFileSync("git", ["branch", "--show-current"], {
+      cwd: worktreeCwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+    }).trim();
+  } catch {
+    worktreeBranch = null;
+  }
+
+  if (worktreeCwd !== projectRoot && worktreeBranch === milestoneBranch) {
+    const status = execFileSync("git", ["status", "--porcelain"], {
+      cwd: worktreeCwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+    }).trim();
+    if (status) {
+      throw new GSDError(
+        GSD_GIT_ERROR,
+        `slice-cadence cannot advance ${milestoneBranch}: worktree has uncommitted changes. Status:\n${status}`,
+      );
+    }
+    execFileSync("git", ["reset", "--hard", mainBranch], {
+      cwd: worktreeCwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+    });
+    return;
+  }
+
+  nativeBranchForceReset(projectRoot, milestoneBranch, mainBranch);
+}
+
 export interface SliceMergeResult {
   commitSha: string | null;
   mainBranch: string;
@@ -91,7 +148,14 @@ export function mergeSliceToMain(
   const started = Date.now();
   const worktreeCwd = process.cwd();
   const milestoneBranch = milestoneBranchName(milestoneId);
-  const mainBranch = nativeDetectMainBranch(projectRoot);
+  const mainBranch = resolveIntegrationBranch(projectRoot, milestoneId);
+
+  if (mainBranch === milestoneBranch) {
+    throw new GSDError(
+      GSD_GIT_ERROR,
+      `slice-cadence resolved integration branch "${mainBranch}" to the milestone branch; refusing to self-merge.`,
+    );
+  }
 
   // Fast path: if the milestone branch has no commits ahead of main, there
   // is nothing to merge. Return a skip result instead of no-op'ing silently
@@ -167,9 +231,10 @@ export function mergeSliceToMain(
     );
 
     // Advance the milestone branch to main so the next slice's commits start
-    // from a clean base. Force-reset is safe because we just merged this
-    // branch's entire delta.
-    nativeBranchForceReset(projectRoot, milestoneBranch, mainBranch);
+    // from a clean base. When the milestone branch is checked out in an auto
+    // worktree, Git refuses a project-root branch -f; reset from inside the
+    // checked-out worktree instead.
+    advanceMilestoneBranch(projectRoot, worktreeCwd, milestoneBranch, mainBranch);
 
     const durationMs = Date.now() - started;
     try {
@@ -211,7 +276,7 @@ export function resquashMilestoneOnMain(
   milestoneId: string,
   startSha: string,
 ): { resquashed: boolean; newSha: string | null } {
-  const mainBranch = nativeDetectMainBranch(projectRoot);
+  const mainBranch = resolveIntegrationBranch(projectRoot, milestoneId);
   const worktreeCwd = process.cwd();
 
   process.chdir(projectRoot);

package/src/resources/extensions/gsd/slice-parallel-orchestrator.ts

@@ -82,6 +82,7 @@ let sliceState: SliceOrchestratorState | null = null;
 
 const SLICE_ORCHESTRATOR_STATE_FILE = "slice-orchestrator.json";
 const TMP_SUFFIX = ".tmp";
+export const SLICE_WORKER_AUTO_ARGS = ["headless", "--json", "auto"] as const;
 
 interface PersistedSliceWorker {
   milestoneId: string;
@@ -356,7 +357,7 @@ export function getSliceOrchestratorState(): SliceOrchestratorState | null {
 /**
  * Start parallel execution for eligible slices within a milestone.
  *
- * For each eligible slice: create a worktree, spawn `gsd --mode json --print "/gsd auto"`
+ * For each eligible slice: create a worktree, spawn `gsd headless --json auto`
  * with env GSD_SLICE_LOCK=<SID> + GSD_MILESTONE_LOCK=<MID> + GSD_PARALLEL_WORKER=1.
  */
 export async function startSliceParallel(
@@ -598,8 +599,13 @@ function resolveGsdBin(): string | null {
 
 /**
  * Spawn a worker process for a slice.
- * The worker runs `gsd --mode json --print "/gsd auto"` in the slice's worktree
+ * The worker runs `gsd headless --json auto` in the slice's worktree
  * with GSD_SLICE_LOCK, GSD_MILESTONE_LOCK, and GSD_PARALLEL_WORKER set.
+ *
+ * Print-mode slash commands return after the command handler schedules
+ * auto-mode, so the worker process can exit before doing any LLM work. The
+ * headless auto entrypoint keeps the process alive until auto-mode reaches a
+ * terminal notification, matching milestone-level parallel workers.
  */
 function spawnSliceWorker(
   basePath: string,
@@ -616,7 +622,7 @@ function spawnSliceWorker(
 
   let child: ChildProcess;
   try {
-    child = spawn(process.execPath, [binPath, "--mode", "json", "--print", "/gsd auto"], {
+    child = spawn(process.execPath, [binPath, ...SLICE_WORKER_AUTO_ARGS], {
       cwd: worker.worktreePath,
       env: {
         ...process.env,