gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.1afbdaa

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -13,14 +13,12 @@
 import { deriveState } from "./state.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
-import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, gsdRoot, } from "./paths.js";
+import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, } from "./auto-recovery.js";
-import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.js";
-import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
-import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
+import { regenerateIfMissing } from "./workflow-projections.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
@@ -30,7 +28,6 @@ import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { atomicWriteSync } from "./atomic-write.js";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
 /**
  * Detect summary files written directly to disk without the LLM calling
@@ -137,8 +134,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     }
     return rogues;
 }
-/** Throttle STATE.md rebuilds — at most once per 30 seconds */
-const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -232,74 +227,6 @@ export async function postUnitPreVerification(pctx, opts) {
         catch (e) {
             debugLog("postUnit", { phase: "github-sync", error: String(e) });
         }
-        // Doctor: fix mechanical bookkeeping (skipped for lightweight sidecars)
-        if (!opts?.skipDoctor)
-            try {
-                const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
-                const doctorScope = scopeParts.join("/");
-                const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
-                const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
-                const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
-                // Human-readable fix notification with details
-                if (report.fixesApplied.length > 0) {
-                    const fixSummary = report.fixesApplied.length <= 2
-                        ? report.fixesApplied.join("; ")
-                        : `${report.fixesApplied[0]}; +${report.fixesApplied.length - 1} more`;
-                    ctx.ui.notify(`Doctor: ${fixSummary}`, "info");
-                }
-                // Proactive health tracking — filter to current milestone to avoid
-                // cross-milestone stale errors inflating the escalation counter
-                const currentMilestoneId = s.currentUnit.id.split("/")[0];
-                const milestoneIssues = currentMilestoneId
-                    ? report.issues.filter(i => i.unitId === currentMilestoneId ||
-                        i.unitId.startsWith(`${currentMilestoneId}/`))
-                    : report.issues;
-                const summary = summarizeDoctorIssues(milestoneIssues);
-                // Pass issue details + scope for real-time visibility in the progress widget
-                const issueDetails = milestoneIssues
-                    .filter(i => i.severity === "error" || i.severity === "warning")
-                    .map(i => ({ code: i.code, message: i.message, severity: i.severity, unitId: i.unitId }));
-                recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length, issueDetails, report.fixesApplied, doctorScope);
-                // Check if we should escalate to LLM-assisted heal
-                if (summary.errors > 0) {
-                    const unresolvedErrors = milestoneIssues
-                        .filter(i => i.severity === "error" && !i.fixable)
-                        .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
-                    const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
-                    if (escalation.shouldEscalate) {
-                        ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
-                        try {
-                            const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
-                            const { dispatchDoctorHeal } = await import("./commands-handlers.js");
-                            const actionable = report.issues.filter(i => i.severity === "error");
-                            const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
-                            const structuredIssues = formatDoctorIssuesForPrompt(actionable);
-                            dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
-                            return "dispatched";
-                        }
-                        catch (e) {
-                            debugLog("postUnit", { phase: "doctor-heal-dispatch", error: String(e) });
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                debugLog("postUnit", { phase: "doctor", error: String(e) });
-            }
-        // Throttled STATE.md rebuild (skipped for lightweight sidecars)
-        if (!opts?.skipStateRebuild) {
-            const now = Date.now();
-            if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
-                try {
-                    await rebuildState(s.basePath);
-                    s.lastStateRebuildAt = now;
-                    autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
-                }
-                catch (e) {
-                    debugLog("postUnit", { phase: "state-rebuild", error: String(e) });
-                }
-            }
-        }
         // Prune dead bg-shell processes
         try {
             const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
@@ -411,6 +338,27 @@ export async function postUnitPreVerification(pctx, opts) {
             catch (e) {
                 debugLog("postUnit", { phase: "artifact-verify", error: String(e) });
             }
+            // If verification failed, attempt to regenerate missing projection files
+            // from DB data before giving up (e.g. research-slice produces PLAN from engine).
+            if (!triggerArtifactVerified) {
+                try {
+                    const parts = s.currentUnit.id.split("/");
+                    const [mid, sid] = parts;
+                    if (mid && sid) {
+                        const regenerated = regenerateIfMissing(s.basePath, mid, sid, "PLAN");
+                        if (regenerated) {
+                            // Re-check after regeneration
+                            triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                            if (triggerArtifactVerified) {
+                                invalidateAllCaches();
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    debugLog("postUnit", { phase: "regenerate-projection", error: String(e) });
+                }
+            }
             // When artifact verification fails for a unit type that has a known expected
             // artifact, return "retry" so the caller re-dispatches with failure context
             // instead of blindly re-dispatching the same unit (#1571).
@@ -432,18 +380,7 @@ export async function postUnitPreVerification(pctx, opts) {
             }
         }
         else {
-            // Hook unit completed — finalize its runtime record
-            try {
-                writeUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, {
-                    phase: "finalized",
-                    progressCount: 1,
-                    lastProgressKind: "hook-completed",
-                });
-                clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
-            }
-            catch (e) {
-                debugLog("postUnit", { phase: "hook-finalize", error: String(e) });
-            }
+            // Hook unit completed — no additional processing needed
         }
     }
     return "continue";
@@ -517,15 +454,7 @@ export async function postUnitPostVerification(pctx) {
                             }
                         }
                     }
-                    // 3. Remove from s.completedUnits and flush to completed-units.json
-                    s.completedUnits = s.completedUnits.filter(u => !(u.type === trigger.unitType && u.id === trigger.unitId));
-                    try {
-                        const completedKeysPath = join(gsdRoot(s.basePath), "completed-units.json");
-                        const keys = s.completedUnits.map(u => `${u.type}/${u.id}`);
-                        atomicWriteSync(completedKeysPath, JSON.stringify(keys, null, 2));
-                    }
-                    catch { /* non-fatal: disk flush failure */ }
-                    // 4. Delete the retry_on artifact (e.g. NEEDS-REWORK.md)
+                    // 3. Delete the retry_on artifact (e.g. NEEDS-REWORK.md)
                     if (trigger.retryArtifact) {
                         const retryArtifactPath = resolveHookArtifactPath(s.basePath, trigger.unitId, trigger.retryArtifact);
                         if (existsSync(retryArtifactPath)) {

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -1156,6 +1156,12 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
         roadmapPath: roadmapRel,
         inlinedContext,
         milestoneSummaryPath,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext],
+        }),
     });
 }
 export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
@@ -1236,6 +1242,12 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         inlinedContext,
         validationPath: validationOutputPath,
         remediationRound: String(remediationRound),
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext],
+        }),
     });
 }
 export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
@@ -1332,6 +1344,12 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
         uatResultPath,
         uatType,
         inlinedContext,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            sliceId,
+            extraContext: [inlinedContext],
+        }),
     });
 }
 export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base, level) {
@@ -1378,11 +1396,16 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
         milestoneTitle: midTitle,
         completedSliceId,
         roadmapPath: roadmapRel,
-        completedSliceSummaryPath: summaryRel,
         assessmentPath,
         inlinedContext,
         deferredCaptures,
         commitInstruction: reassessCommitInstruction,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext, deferredCaptures],
+        }),
     });
 }
 // ─── Reactive Execute Prompt ──────────────────────────────────────────────

package/dist/resources/extensions/gsd/auto-start.js

@@ -197,10 +197,13 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 state = await deriveState(wtPath);
             }
         }
-        // Milestone branch recovery (#601)
+        // Milestone branch recovery (#601, #2358)
+        // Detect survivor milestone branches in both pre-planning and complete phases.
+        // In phase=complete, the milestone artifacts exist but finalization (merge,
+        // worktree cleanup) was never run — the survivor branch must be merged.
         let hasSurvivorBranch = false;
         if (state.activeMilestone &&
-            state.phase === "pre-planning" &&
+            (state.phase === "pre-planning" || state.phase === "complete") &&
             shouldUseWorktreeIsolation() &&
             !detectWorktreeName(base) &&
             !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)) {
@@ -231,6 +234,22 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 return releaseLockAndReturn();
             }
         }
+        // Survivor branch exists and milestone is complete (#2358):
+        // The milestone artifacts were written but finalization (merge, worktree
+        // cleanup) never ran. Run mergeAndExit to finalize, then re-derive state
+        // so the normal "all milestones complete" or "next milestone" path runs.
+        if (hasSurvivorBranch && state.phase === "complete") {
+            const mid = state.activeMilestone.id;
+            ctx.ui.notify(`Milestone ${mid} is complete but branch/worktree was not finalized. Running merge now.`, "info");
+            const resolver = buildResolver();
+            resolver.mergeAndExit(mid, {
+                notify: ctx.ui.notify.bind(ctx.ui),
+            });
+            invalidateAllCaches();
+            state = await deriveState(base);
+            // Clear survivor flag — finalization is done
+            hasSurvivorBranch = false;
+        }
         if (!hasSurvivorBranch) {
             // No active work — start a new milestone via discuss flow
             if (!state.activeMilestone || state.phase === "complete") {
@@ -333,7 +352,6 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         });
         s.autoStartTime = Date.now();
         s.resourceVersionOnStart = readResourceVersion();
-        s.completedUnits = [];
         s.pendingQuickTasks = [];
         s.currentUnit = null;
         s.currentMilestoneId = state.activeMilestone?.id ?? null;
@@ -436,8 +454,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ? `Will loop through ${pendingCount} milestones.`
             : "Will loop until milestone complete.";
         ctx.ui.notify(`${modeLabel} started. ${scopeMsg}`, "info");
-        updateSessionLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown", 0);
-        writeLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown", 0);
+        updateSessionLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown");
+        writeLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown");
         // Secrets collection gate
         const mid = state.activeMilestone.id;
         try {

package/dist/resources/extensions/gsd/auto-timers.js

@@ -6,6 +6,7 @@
  * via startUnitSupervision() and torn down by the caller via clearUnitTimeout().
  */
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveAutoSupervisorConfig } from "./preferences.js";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
 import { getInFlightToolCount, getOldestInFlightToolStart, } from "./auto-tool-tracking.js";
@@ -21,12 +22,65 @@ import { resolveAgentEndCancelled } from "./auto/resolve.js";
  * 3. Hard timeout (pause + recovery)
  * 4. Context-pressure monitor (continue-here)
  */
+/**
+ * Parse a task estimate string (e.g. "30m", "2h", "1h30m") into minutes.
+ * Returns null if the string cannot be parsed.
+ */
+export function parseEstimateMinutes(estimate) {
+    if (!estimate || typeof estimate !== "string")
+        return null;
+    const trimmed = estimate.trim();
+    if (!trimmed)
+        return null;
+    let totalMinutes = 0;
+    let matched = false;
+    // Match hours component
+    const hoursMatch = trimmed.match(/(\d+)\s*h/i);
+    if (hoursMatch) {
+        totalMinutes += Number(hoursMatch[1]) * 60;
+        matched = true;
+    }
+    // Match minutes component
+    const minutesMatch = trimmed.match(/(\d+)\s*m/i);
+    if (minutesMatch) {
+        totalMinutes += Number(minutesMatch[1]);
+        matched = true;
+    }
+    return matched ? totalMinutes : null;
+}
 export function startUnitSupervision(sctx) {
     const { s, ctx, pi, unitType, unitId, prefs, buildSnapshotOpts, buildRecoveryContext, pauseAuto } = sctx;
     const supervisor = resolveAutoSupervisorConfig();
-    const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000;
-    const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000;
-    const hardTimeoutMs = (supervisor.hard_timeout_minutes ?? 0) * 60 * 1000;
+    // Scale timeouts based on task estimate annotations (#2243).
+    // If the task has an est: annotation, use it to extend the hard and soft timeouts
+    // so longer tasks don't get prematurely timed out.
+    let taskEstimate = sctx.taskEstimate;
+    if (!taskEstimate && unitType === "task" && isDbAvailable()) {
+        // Look up the task estimate from the DB (#2243).
+        try {
+            if (s.currentMilestoneId) {
+                const slices = getMilestoneSlices(s.currentMilestoneId);
+                for (const slice of slices) {
+                    const tasks = getSliceTasks(s.currentMilestoneId, slice.id);
+                    const task = tasks.find(t => t.id === unitId);
+                    if (task?.estimate) {
+                        taskEstimate = task.estimate;
+                        break;
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-fatal — fall through with no estimate
+        }
+    }
+    const estimateMinutes = taskEstimate ? parseEstimateMinutes(taskEstimate) : null;
+    const timeoutScale = estimateMinutes && estimateMinutes > 0
+        ? Math.max(1, estimateMinutes / 10) // 10min task = 1x, 30min = 3x, 2h = 12x
+        : 1;
+    const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000 * timeoutScale;
+    const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000; // idle not scaled — idle is idle
+    const hardTimeoutMs = (supervisor.hard_timeout_minutes ?? 0) * 60 * 1000 * timeoutScale;
     // ── 1. Soft timeout warning ──
     s.wrapupWarningHandle = setTimeout(() => {
         s.wrapupWarningHandle = null;

package/dist/resources/extensions/gsd/auto-worktree-sync.js

@@ -63,6 +63,10 @@ export function syncStateToProjectRoot(worktreePath, projectRoot, milestoneId) {
     // 2. Milestone directory — ROADMAP, slice PLANs, task summaries
     // Copy the entire milestone .gsd subtree so deriveState reads current checkboxes
     safeCopyRecursive(join(wtGsd, "milestones", milestoneId), join(prGsd, "milestones", milestoneId), { force: true });
+    // 3. metrics.json — session cost/token tracking (#2313).
+    // Without this, metrics accumulated in the worktree are invisible from the
+    // project root and never appear in the dashboard or skill-health reports.
+    safeCopy(join(wtGsd, "metrics.json"), join(prGsd, "metrics.json"), { force: true });
     // 4. Runtime records — unit dispatch state used by selfHealRuntimeRecords().
     // Without this, a crash during a unit leaves the runtime record only in the
     // worktree. If the next session resolves basePath before worktree re-entry,

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -17,6 +17,7 @@ import { createWorktree, removeWorktree, resolveGitDir, worktreePath, } from "./
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
 import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { debugLog } from "./debug-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, } from "./native-git-bridge.js";
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -109,6 +110,7 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
         "OVERRIDES.md",
         "QUEUE.md",
         "completed-units.json",
+        "metrics.json",
     ];
     for (const f of rootFiles) {
         const src = join(mainGsd, f);
@@ -269,8 +271,9 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
     // ── 1. Sync root-level .gsd/ files back ──────────────────────────────
     // The worktree is authoritative — complete-milestone updates REQUIREMENTS,
     // PROJECT, etc. These must overwrite main's copies so they survive teardown.
-    // Also includes QUEUE.md and completed-units.json which are written during
-    // milestone closeout and lost on teardown without explicit sync (#1787).
+    // Also includes QUEUE.md, completed-units.json, and metrics.json which are
+    // written during milestone closeout and lost on teardown without explicit sync
+    // (#1787, #2313).
     const rootFiles = [
         "DECISIONS.md",
         "REQUIREMENTS.md",
@@ -279,6 +282,7 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
         "OVERRIDES.md",
         "QUEUE.md",
         "completed-units.json",
+        "metrics.json",
     ];
     for (const f of rootFiles) {
         const src = join(wtGsd, f);
@@ -612,7 +616,7 @@ export function createAutoWorktree(basePath, milestoneId) {
     const hookError = runWorktreePostCreateHook(basePath, info.path);
     if (hookError) {
         // Non-fatal — log but don't prevent worktree usage
-        console.error(`[GSD] ${hookError}`);
+        logWarning("reconcile", hookError, { worktree: info.name });
     }
     const previousCwd = process.cwd();
     try {
@@ -687,9 +691,9 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
     // backslashes (#1436), leaving ~1 GB+ orphaned directories.
     const wtDir = worktreePath(originalBasePath, milestoneId);
     if (existsSync(wtDir)) {
-        console.error(`[GSD] WARNING: Worktree directory still exists after teardown: ${wtDir}\n` +
-            `  This is likely an orphaned directory consuming disk space.\n` +
-            `  Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`);
+        logWarning("reconcile", `Worktree directory still exists after teardown: ${wtDir}. ` +
+            `This is likely an orphaned directory consuming disk space. ` +
+            `Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`, { worktree: milestoneId });
         // Attempt a direct filesystem removal as a fallback
         try {
             rmSync(wtDir, { recursive: true, force: true });
@@ -1133,9 +1137,9 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             // Push failure is non-fatal
         }
     }
-    // 9b. Auto-create PR if enabled (requires push_branches + push succeeded)
+    // 9b. Auto-create PR if enabled (#2302: no longer gated on pushed/auto_push)
     let prCreated = false;
-    if (prefs.auto_pr === true && pushed) {
+    if (prefs.auto_pr === true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
         const prTarget = prefs.pr_target_branch ?? mainBranch;
         try {
@@ -1145,9 +1149,9 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                 stdio: ["ignore", "pipe", "pipe"],
                 encoding: "utf-8",
             });
-            // Create PR via gh CLI
+            // Create PR via gh CLI with explicit --head and --base (#2302)
             execFileSync("gh", [
-                "pr", "create",
+                "pr", "create", "--draft",
                 "--base", prTarget,
                 "--head", milestoneBranch,
                 "--title", `Milestone ${milestoneId} complete`,