gsd-pi 2.31.2 → 2.32.0

package/dist/worktree-cli.js

@@ -12,18 +12,53 @@
  * On session exit (via session_shutdown event), auto-commits dirty work
  * so nothing is lost. The GSD extension reads GSD_CLI_WORKTREE to know
  * when a session was launched via -w.
+ *
+ * Note: Extension modules are .ts files loaded via jiti (not compiled to .js).
+ * We use createJiti() here because this module is compiled by tsc but imports
+ * from resources/extensions/gsd/ which are shipped as raw .ts (#1283).
  */
 import chalk from 'chalk';
-import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, worktreeBranchName, } from './resources/extensions/gsd/worktree-manager.js';
-import { runWorktreePostCreateHook } from './resources/extensions/gsd/auto-worktree.js';
+import { createJiti } from '@mariozechner/jiti';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 import { generateWorktreeName } from './worktree-name-gen.js';
-import { nativeHasChanges, nativeDetectMainBranch, nativeCommitCountBetween, } from './resources/extensions/gsd/native-git-bridge.js';
-import { inferCommitType } from './resources/extensions/gsd/git-service.js';
 import { existsSync } from 'node:fs';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+// Lazily-loaded extension modules (loaded once on first use via jiti)
+let _ext = null;
+async function loadExtensionModules() {
+    if (_ext)
+        return _ext;
+    const [wtMgr, autoWt, gitBridge, gitSvc, wt] = await Promise.all([
+        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree-manager.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/auto-worktree.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/native-git-bridge.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/git-service.ts'), {}),
+        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree.ts'), {}),
+    ]);
+    _ext = {
+        createWorktree: wtMgr.createWorktree,
+        listWorktrees: wtMgr.listWorktrees,
+        removeWorktree: wtMgr.removeWorktree,
+        mergeWorktreeToMain: wtMgr.mergeWorktreeToMain,
+        diffWorktreeAll: wtMgr.diffWorktreeAll,
+        diffWorktreeNumstat: wtMgr.diffWorktreeNumstat,
+        worktreeBranchName: wtMgr.worktreeBranchName,
+        worktreePath: wtMgr.worktreePath,
+        runWorktreePostCreateHook: autoWt.runWorktreePostCreateHook,
+        nativeHasChanges: gitBridge.nativeHasChanges,
+        nativeDetectMainBranch: gitBridge.nativeDetectMainBranch,
+        nativeCommitCountBetween: gitBridge.nativeCommitCountBetween,
+        inferCommitType: gitSvc.inferCommitType,
+        autoCommitCurrentBranch: wt.autoCommitCurrentBranch,
+    };
+    return _ext;
+}
 // ─── Status Helpers ─────────────────────────────────────────────────────────
-function getWorktreeStatus(basePath, name, wtPath) {
-    const diff = diffWorktreeAll(basePath, name);
-    const numstat = diffWorktreeNumstat(basePath, name);
+function getWorktreeStatus(ext, basePath, name, wtPath) {
+    const diff = ext.diffWorktreeAll(basePath, name);
+    const numstat = ext.diffWorktreeNumstat(basePath, name);
     const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
     let linesAdded = 0;
     let linesRemoved = 0;
@@ -33,19 +68,19 @@ function getWorktreeStatus(basePath, name, wtPath) {
     }
     let uncommitted = false;
     try {
-        uncommitted = existsSync(wtPath) && nativeHasChanges(wtPath);
+        uncommitted = existsSync(wtPath) && ext.nativeHasChanges(wtPath);
     }
     catch { /* */ }
     let commits = 0;
     try {
-        const mainBranch = nativeDetectMainBranch(basePath);
-        commits = nativeCommitCountBetween(basePath, mainBranch, worktreeBranchName(name));
+        const mainBranch = ext.nativeDetectMainBranch(basePath);
+        commits = ext.nativeCommitCountBetween(basePath, mainBranch, ext.worktreeBranchName(name));
     }
     catch { /* */ }
     return {
         name,
         path: wtPath,
-        branch: worktreeBranchName(name),
+        branch: ext.worktreeBranchName(name),
         exists: existsSync(wtPath),
         filesChanged,
         linesAdded,
@@ -71,65 +106,66 @@ function formatStatus(s) {
     return lines.join('\n');
 }
 // ─── Subcommand: list ───────────────────────────────────────────────────────
-function handleList(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleList(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0) {
         process.stderr.write(chalk.dim('No worktrees. Create one with: gsd -w <name>\n'));
         return;
     }
     process.stderr.write(chalk.bold('\nWorktrees\n\n'));
     for (const wt of worktrees) {
-        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
         process.stderr.write(formatStatus(status) + '\n\n');
     }
 }
 // ─── Subcommand: merge ──────────────────────────────────────────────────────
 async function handleMerge(basePath, args) {
+    const ext = await loadExtensionModules();
     const name = args[0];
     if (!name) {
         // If only one worktree exists, merge it
-        const worktrees = listWorktrees(basePath);
+        const worktrees = ext.listWorktrees(basePath);
         if (worktrees.length === 1) {
-            await doMerge(basePath, worktrees[0].name);
+            await doMerge(ext, basePath, worktrees[0].name);
             return;
         }
         process.stderr.write(chalk.red('Usage: gsd worktree merge <name>\n'));
         process.stderr.write(chalk.dim('Run gsd worktree list to see worktrees.\n'));
         process.exit(1);
     }
-    await doMerge(basePath, name);
+    await doMerge(ext, basePath, name);
 }
-async function doMerge(basePath, name) {
-    const worktrees = listWorktrees(basePath);
+async function doMerge(ext, basePath, name) {
+    const worktrees = ext.listWorktrees(basePath);
     const wt = worktrees.find(w => w.name === name);
     if (!wt) {
         process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
         process.exit(1);
     }
-    const status = getWorktreeStatus(basePath, name, wt.path);
+    const status = getWorktreeStatus(ext, basePath, name, wt.path);
     if (status.filesChanged === 0 && !status.uncommitted) {
         process.stderr.write(chalk.dim(`Worktree "${name}" has no changes to merge.\n`));
         // Clean up empty worktree
-        removeWorktree(basePath, name, { deleteBranch: true });
+        ext.removeWorktree(basePath, name, { deleteBranch: true });
         process.stderr.write(chalk.green(`Removed empty worktree ${chalk.bold(name)}.\n`));
         return;
     }
     // Auto-commit dirty work before merge
     if (status.uncommitted) {
         try {
-            const { autoCommitCurrentBranch } = await import('./resources/extensions/gsd/worktree.js');
-            autoCommitCurrentBranch(wt.path, 'worktree-merge', name);
+            ext.autoCommitCurrentBranch(wt.path, 'worktree-merge', name);
             process.stderr.write(chalk.dim('  Auto-committed dirty work before merge.\n'));
         }
         catch { /* best-effort */ }
     }
-    const commitType = inferCommitType(name);
+    const commitType = ext.inferCommitType(name);
     const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
-    process.stderr.write(`\nMerging ${chalk.bold.cyan(name)} → ${chalk.magenta(nativeDetectMainBranch(basePath))}\n`);
+    process.stderr.write(`\nMerging ${chalk.bold.cyan(name)} → ${chalk.magenta(ext.nativeDetectMainBranch(basePath))}\n`);
     process.stderr.write(chalk.dim(`  ${status.filesChanged} files, ${chalk.green(`+${status.linesAdded}`)} ${chalk.red(`-${status.linesRemoved}`)}\n\n`));
     try {
-        mergeWorktreeToMain(basePath, name, commitMessage);
-        removeWorktree(basePath, name, { deleteBranch: true });
+        ext.mergeWorktreeToMain(basePath, name, commitMessage);
+        ext.removeWorktree(basePath, name, { deleteBranch: true });
         process.stderr.write(chalk.green(`✓ Merged and cleaned up ${chalk.bold(name)}\n`));
         process.stderr.write(chalk.dim(`  commit: ${commitMessage}\n`));
     }
@@ -141,18 +177,19 @@ async function doMerge(basePath, name) {
     }
 }
 // ─── Subcommand: clean ──────────────────────────────────────────────────────
-function handleClean(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleClean(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0) {
         process.stderr.write(chalk.dim('No worktrees to clean.\n'));
         return;
     }
     let cleaned = 0;
     for (const wt of worktrees) {
-        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
         if (status.filesChanged === 0 && !status.uncommitted) {
             try {
-                removeWorktree(basePath, wt.name, { deleteBranch: true });
+                ext.removeWorktree(basePath, wt.name, { deleteBranch: true });
                 process.stderr.write(chalk.green(`  ✓ Removed ${chalk.bold(wt.name)} (clean)\n`));
                 cleaned++;
             }
@@ -167,19 +204,20 @@ function handleClean(basePath) {
     process.stderr.write(chalk.dim(`\nCleaned ${cleaned} worktree${cleaned === 1 ? '' : 's'}.\n`));
 }
 // ─── Subcommand: remove ─────────────────────────────────────────────────────
-function handleRemove(basePath, args) {
+async function handleRemove(basePath, args) {
+    const ext = await loadExtensionModules();
     const name = args[0];
     if (!name) {
         process.stderr.write(chalk.red('Usage: gsd worktree remove <name>\n'));
         process.exit(1);
     }
-    const worktrees = listWorktrees(basePath);
+    const worktrees = ext.listWorktrees(basePath);
     const wt = worktrees.find(w => w.name === name);
     if (!wt) {
         process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
         process.exit(1);
     }
-    const status = getWorktreeStatus(basePath, name, wt.path);
+    const status = getWorktreeStatus(ext, basePath, name, wt.path);
     if (status.filesChanged > 0 || status.uncommitted) {
         process.stderr.write(chalk.yellow(`⚠ Worktree "${name}" has unmerged changes (${status.filesChanged} files).\n`));
         process.stderr.write(chalk.yellow('  Use --force to remove anyway, or merge first: gsd worktree merge ' + name + '\n'));
@@ -187,17 +225,18 @@ function handleRemove(basePath, args) {
             process.exit(1);
         }
     }
-    removeWorktree(basePath, name, { deleteBranch: true });
+    ext.removeWorktree(basePath, name, { deleteBranch: true });
     process.stderr.write(chalk.green(`✓ Removed worktree ${chalk.bold(name)}\n`));
 }
 // ─── Subcommand: status (default when no args) ─────────────────────────────
-function handleStatusBanner(basePath) {
-    const worktrees = listWorktrees(basePath);
+async function handleStatusBanner(basePath) {
+    const ext = await loadExtensionModules();
+    const worktrees = ext.listWorktrees(basePath);
     if (worktrees.length === 0)
         return;
     const withChanges = worktrees.filter(wt => {
         try {
-            const diff = diffWorktreeAll(basePath, wt.name);
+            const diff = ext.diffWorktreeAll(basePath, wt.name);
             return diff.added.length + diff.modified.length + diff.removed.length > 0;
         }
         catch {
@@ -214,14 +253,15 @@ function handleStatusBanner(basePath) {
         chalk.dim('Resume: gsd -w <name>  |  Merge: gsd worktree merge <name>  |  List: gsd worktree list\n\n'));
 }
 // ─── -w flag: create/resume worktree for interactive session ────────────────
-function handleWorktreeFlag(worktreeFlag) {
+async function handleWorktreeFlag(worktreeFlag) {
+    const ext = await loadExtensionModules();
     const basePath = process.cwd();
     // gsd -w (no name) — resume most recent worktree with changes, or create new
     if (worktreeFlag === true) {
-        const existing = listWorktrees(basePath);
+        const existing = ext.listWorktrees(basePath);
         const withChanges = existing.filter(wt => {
             try {
-                const diff = diffWorktreeAll(basePath, wt.name);
+                const diff = ext.diffWorktreeAll(basePath, wt.name);
                 return diff.added.length + diff.modified.length + diff.removed.length > 0;
             }
             catch {
@@ -243,7 +283,7 @@ function handleWorktreeFlag(worktreeFlag) {
             // Multiple active worktrees — show them and ask user to pick
             process.stderr.write(chalk.yellow(`${withChanges.length} worktrees have unmerged changes:\n\n`));
             for (const wt of withChanges) {
-                const status = getWorktreeStatus(basePath, wt.name, wt.path);
+                const status = getWorktreeStatus(ext, basePath, wt.name, wt.path);
                 process.stderr.write(formatStatus(status) + '\n\n');
             }
             process.stderr.write(chalk.dim('Specify which one: gsd -w <name>\n'));
@@ -251,12 +291,12 @@ function handleWorktreeFlag(worktreeFlag) {
         }
         // No active worktrees — create a new one
         const name = generateWorktreeName();
-        createAndEnter(basePath, name);
+        await createAndEnter(ext, basePath, name);
         return;
     }
     // gsd -w <name> — create or resume named worktree
     const name = worktreeFlag;
-    const existing = listWorktrees(basePath);
+    const existing = ext.listWorktrees(basePath);
     const found = existing.find(wt => wt.name === name);
     if (found) {
         process.chdir(found.path);
@@ -267,13 +307,13 @@ function handleWorktreeFlag(worktreeFlag) {
         process.stderr.write(chalk.dim(`  branch ${found.branch}\n\n`));
     }
     else {
-        createAndEnter(basePath, name);
+        await createAndEnter(ext, basePath, name);
     }
 }
-function createAndEnter(basePath, name) {
+async function createAndEnter(ext, basePath, name) {
     try {
-        const info = createWorktree(basePath, name);
-        const hookError = runWorktreePostCreateHook(basePath, info.path);
+        const info = ext.createWorktree(basePath, name);
+        const hookError = ext.runWorktreePostCreateHook(basePath, info.path);
         if (hookError) {
             process.stderr.write(chalk.yellow(`[gsd] ${hookError}\n`));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.31.2",
+  "version": "2.32.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.31.2",
+  "version": "2.32.0",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "piConfig": {

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.31.2",
+  "version": "2.32.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/gsd/auto-constants.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared constants for auto-mode modules (auto.ts, auto-post-unit.ts, etc.).
+ */
+
+/** Throttle STATE.md rebuilds — at most once per 30 seconds. */
+export const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -48,40 +48,34 @@ export interface AutoDashboardData {
 
 // ─── Unit Description Helpers ─────────────────────────────────────────────────
 
+/** Canonical verb and phase label for each known unit type. */
+const UNIT_TYPE_INFO: Record<string, { verb: string; phaseLabel: string }> = {
+  "research-milestone": { verb: "researching",  phaseLabel: "RESEARCH" },
+  "research-slice":     { verb: "researching",  phaseLabel: "RESEARCH" },
+  "plan-milestone":     { verb: "planning",     phaseLabel: "PLAN" },
+  "plan-slice":         { verb: "planning",     phaseLabel: "PLAN" },
+  "execute-task":       { verb: "executing",    phaseLabel: "EXECUTE" },
+  "complete-slice":     { verb: "completing",   phaseLabel: "COMPLETE" },
+  "replan-slice":       { verb: "replanning",   phaseLabel: "REPLAN" },
+  "rewrite-docs":       { verb: "rewriting",    phaseLabel: "REWRITE" },
+  "reassess-roadmap":   { verb: "reassessing",  phaseLabel: "REASSESS" },
+  "run-uat":            { verb: "running UAT",  phaseLabel: "UAT" },
+};
+
 export function unitVerb(unitType: string): string {
   if (unitType.startsWith("hook/")) return `hook: ${unitType.slice(5)}`;
-  switch (unitType) {
-    case "research-milestone":
-    case "research-slice": return "researching";
-    case "plan-milestone":
-    case "plan-slice": return "planning";
-    case "execute-task": return "executing";
-    case "complete-slice": return "completing";
-    case "replan-slice": return "replanning";
-    case "rewrite-docs": return "rewriting";
-    case "reassess-roadmap": return "reassessing";
-    case "run-uat": return "running UAT";
-    default: return unitType;
-  }
+  return UNIT_TYPE_INFO[unitType]?.verb ?? unitType;
 }
 
 export function unitPhaseLabel(unitType: string): string {
   if (unitType.startsWith("hook/")) return "HOOK";
-  switch (unitType) {
-    case "research-milestone": return "RESEARCH";
-    case "research-slice": return "RESEARCH";
-    case "plan-milestone": return "PLAN";
-    case "plan-slice": return "PLAN";
-    case "execute-task": return "EXECUTE";
-    case "complete-slice": return "COMPLETE";
-    case "replan-slice": return "REPLAN";
-    case "rewrite-docs": return "REWRITE";
-    case "reassess-roadmap": return "REASSESS";
-    case "run-uat": return "UAT";
-    default: return unitType.toUpperCase();
-  }
+  return UNIT_TYPE_INFO[unitType]?.phaseLabel ?? unitType.toUpperCase();
 }
 
+/**
+ * Describe the expected next step after the current unit completes.
+ * Unit types here mirror the keys in UNIT_TYPE_INFO above.
+ */
 function peekNext(unitType: string, state: GSDState): string {
   // Show active hook info in progress display
   const activeHookState = getActiveHook();

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -182,15 +182,10 @@ export async function dispatchDirectPhase(
         ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");
         return;
       }
-      const uatContent = await loadFile(uatFile);
-      if (!uatContent) {
-        ctx.ui.notify("Cannot dispatch run-uat: UAT file is empty.", "warning");
-        return;
-      }
       const uatPath = relSliceFile(base, mid, sid, "UAT");
       unitType = "run-uat";
       unitId = `${mid}/${sid}`;
-      prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, base);
+      prompt = await buildRunUatPrompt(mid, sid, uatPath, base);
       break;
     }
 

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -11,8 +11,7 @@
 
 import type { GSDState } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
-import type { UatType } from "./files.js";
-import { loadFile, extractUatType, loadActiveOverrides, parseRoadmap } from "./files.js";
+import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
 import {
   resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile,
   relSliceFile, buildMilestoneFileName,
@@ -39,7 +38,7 @@ import {
 // ─── Types ────────────────────────────────────────────────────────────────
 
 export type DispatchAction =
-  | { action: "dispatch"; unitType: string; unitId: string; prompt: string; pauseAfterDispatch?: boolean }
+  | { action: "dispatch"; unitType: string; unitId: string; prompt: string }
   | { action: "stop"; reason: string; level: "info" | "warning" | "error" }
   | { action: "skip" };
 
@@ -138,17 +137,14 @@ const DISPATCH_RULES: DispatchRule[] = [
     match: async ({ state, mid, basePath, prefs }) => {
       const needsRunUat = await checkNeedsRunUat(basePath, mid, state, prefs);
       if (!needsRunUat) return null;
-      const { sliceId, uatType } = needsRunUat;
-      const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT")!;
-      const uatContent = await loadFile(uatFile);
+      const { sliceId } = needsRunUat;
       return {
         action: "dispatch",
         unitType: "run-uat",
         unitId: `${mid}/${sliceId}`,
         prompt: await buildRunUatPrompt(
-          mid, sliceId, relSliceFile(basePath, mid, sliceId, "UAT"), uatContent ?? "", basePath,
+          mid, sliceId, relSliceFile(basePath, mid, sliceId, "UAT"), basePath,
         ),
-        pauseAfterDispatch: uatType !== "artifact-driven",
       };
     },
   },

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -60,9 +60,31 @@ import {
   hideFooter,
 } from "./auto-dashboard.js";
 import { join } from "node:path";
+import { STATE_REBUILD_MIN_INTERVAL_MS } from "./auto-constants.js";
 
-/** Throttle STATE.md rebuilds — at most once per 30 seconds */
-const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
+/**
+ * Initialize a unit dispatch: stamp the current time, set `s.currentUnit`,
+ * and persist the initial runtime record. Returns `startedAt` for callers
+ * that need the timestamp.
+ */
+function dispatchUnit(
+  s: AutoSession,
+  basePath: string,
+  unitType: string,
+  unitId: string,
+): number {
+  const startedAt = Date.now();
+  s.currentUnit = { type: unitType, id: unitId, startedAt };
+  writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, {
+    phase: "dispatched",
+    wrapupWarningSent: false,
+    timeoutAt: null,
+    lastProgressAt: startedAt,
+    progressCount: 0,
+    lastProgressKind: "dispatch",
+  });
+  return startedAt;
+}
 
 export interface PostUnitContext {
   s: AutoSession;
@@ -364,19 +386,10 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
   if (s.currentUnit && !s.stepMode) {
     const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
     if (hookUnit) {
-      const hookStartedAt = Date.now();
       if (s.currentUnit) {
         await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
       }
-      s.currentUnit = { type: hookUnit.unitType, id: hookUnit.unitId, startedAt: hookStartedAt };
-      writeUnitRuntimeRecord(s.basePath, hookUnit.unitType, hookUnit.unitId, hookStartedAt, {
-        phase: "dispatched",
-        wrapupWarningSent: false,
-        timeoutAt: null,
-        lastProgressAt: hookStartedAt,
-        progressCount: 0,
-        lastProgressKind: "dispatch",
-      });
+      dispatchUnit(s, s.basePath, hookUnit.unitType, hookUnit.unitId);
 
       const state = await deriveState(s.basePath);
       updateProgressWidget(ctx, hookUnit.unitType, hookUnit.unitId, state);
@@ -498,16 +511,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
 
             const triageUnitType = "triage-captures";
             const triageUnitId = `${mid}/${sid}/triage`;
-            const triageStartedAt = Date.now();
-            s.currentUnit = { type: triageUnitType, id: triageUnitId, startedAt: triageStartedAt };
-            writeUnitRuntimeRecord(s.basePath, triageUnitType, triageUnitId, triageStartedAt, {
-              phase: "dispatched",
-              wrapupWarningSent: false,
-              timeoutAt: null,
-              lastProgressAt: triageStartedAt,
-              progressCount: 0,
-              lastProgressKind: "dispatch",
-            });
+            dispatchUnit(s, s.basePath, triageUnitType, triageUnitId);
             updateProgressWidget(ctx, triageUnitType, triageUnitId, state);
 
             const result = await s.cmdCtx!.newSession();
@@ -568,16 +572,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
 
       const qtUnitType = "quick-task";
       const qtUnitId = `${s.currentMilestoneId}/${capture.id}`;
-      const qtStartedAt = Date.now();
-      s.currentUnit = { type: qtUnitType, id: qtUnitId, startedAt: qtStartedAt };
-      writeUnitRuntimeRecord(s.basePath, qtUnitType, qtUnitId, qtStartedAt, {
-        phase: "dispatched",
-        wrapupWarningSent: false,
-        timeoutAt: null,
-        lastProgressAt: qtStartedAt,
-        progressCount: 0,
-        lastProgressKind: "dispatch",
-      });
+      dispatchUnit(s, s.basePath, qtUnitType, qtUnitId);
       const state = await deriveState(s.basePath);
       updateProgressWidget(ctx, qtUnitType, qtUnitId, state);