gsd-pi 2.16.0 → 2.18.0

package/dist/resources/extensions/gsd/tests/token-profile.test.ts

@@ -0,0 +1,263 @@
+/**
+ * Token Profile — unit tests for M004/S01.
+ *
+ * Tests profile resolution, preference merging, phase skip defaults,
+ * subagent model routing, default-to-balanced behavior, and dispatch
+ * table guard clauses (source-level structural verification).
+ *
+ * Uses source-level checks (readFileSync + string matching) to avoid
+ * @gsd/pi-coding-agent import resolution issues in dev environments.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ─── Source files for structural checks ───────────────────────────────────
+
+const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+const preferencesSrc = readFileSync(join(__dirname, "..", "preferences.ts"), "utf-8");
+const typesSrc = readFileSync(join(__dirname, "..", "types.ts"), "utf-8");
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Type Definitions
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("types: TokenProfile type exported with budget/balanced/quality", () => {
+  assert.ok(typesSrc.includes("export type TokenProfile"), "TokenProfile should be exported");
+  assert.ok(typesSrc.includes("'budget'"), "should include budget");
+  assert.ok(typesSrc.includes("'balanced'"), "should include balanced");
+  assert.ok(typesSrc.includes("'quality'"), "should include quality");
+});
+
+test("types: InlineLevel type exported with full/standard/minimal", () => {
+  assert.ok(typesSrc.includes("export type InlineLevel"), "InlineLevel should be exported");
+  assert.ok(typesSrc.includes("'full'"), "should include full");
+  assert.ok(typesSrc.includes("'standard'"), "should include standard");
+  assert.ok(typesSrc.includes("'minimal'"), "should include minimal");
+});
+
+test("types: PhaseSkipPreferences interface exported", () => {
+  assert.ok(typesSrc.includes("export interface PhaseSkipPreferences"), "PhaseSkipPreferences should be exported");
+  assert.ok(typesSrc.includes("skip_research"), "should include skip_research");
+  assert.ok(typesSrc.includes("skip_reassess"), "should include skip_reassess");
+  assert.ok(typesSrc.includes("skip_slice_research"), "should include skip_slice_research");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// GSDPreferences Interface
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("preferences: GSDPreferences includes token_profile field", () => {
+  assert.ok(
+    preferencesSrc.includes("token_profile?: TokenProfile"),
+    "GSDPreferences should have token_profile field",
+  );
+});
+
+test("preferences: GSDPreferences includes phases field", () => {
+  assert.ok(
+    preferencesSrc.includes("phases?: PhaseSkipPreferences"),
+    "GSDPreferences should have phases field",
+  );
+});
+
+test("preferences: GSDModelConfig includes subagent field", () => {
+  // Check both v1 and v2 configs
+  const v1Match = preferencesSrc.match(/interface GSDModelConfig\s*\{[^}]*subagent/);
+  assert.ok(v1Match, "GSDModelConfig should have subagent field");
+  const v2Match = preferencesSrc.match(/interface GSDModelConfigV2\s*\{[^}]*subagent/);
+  assert.ok(v2Match, "GSDModelConfigV2 should have subagent field");
+});
+
+test("preferences: KNOWN_PREFERENCE_KEYS includes token_profile and phases", () => {
+  assert.ok(preferencesSrc.includes('"token_profile"'), "KNOWN_PREFERENCE_KEYS should include token_profile");
+  assert.ok(preferencesSrc.includes('"phases"'), "KNOWN_PREFERENCE_KEYS should include phases");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Profile Resolution
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("profile: resolveProfileDefaults exists and handles all 3 tiers", () => {
+  assert.ok(
+    preferencesSrc.includes("export function resolveProfileDefaults"),
+    "resolveProfileDefaults should be exported",
+  );
+  assert.ok(
+    preferencesSrc.includes('case "budget"') &&
+    preferencesSrc.includes('case "balanced"') &&
+    preferencesSrc.includes('case "quality"'),
+    "resolveProfileDefaults should handle all 3 tiers",
+  );
+});
+
+test("profile: budget profile sets phase skips to true", () => {
+  // Extract the budget case block
+  const budgetIdx = preferencesSrc.indexOf('case "budget":');
+  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
+  const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
+  assert.ok(budgetBlock.includes("skip_research: true"), "budget should skip research");
+  assert.ok(budgetBlock.includes("skip_reassess: true"), "budget should skip reassess");
+  assert.ok(budgetBlock.includes("skip_slice_research: true"), "budget should skip slice research");
+});
+
+test("profile: balanced profile skips only slice research", () => {
+  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
+  const qualityIdx = preferencesSrc.indexOf('case "quality":');
+  const balancedBlock = preferencesSrc.slice(balancedIdx, qualityIdx);
+  assert.ok(balancedBlock.includes("skip_slice_research: true"), "balanced should skip slice research");
+  assert.ok(!balancedBlock.includes("skip_research: true"), "balanced should NOT skip milestone research");
+  assert.ok(!balancedBlock.includes("skip_reassess: true"), "balanced should NOT skip reassess");
+});
+
+test("profile: quality profile has empty phases (no skips)", () => {
+  const qualityIdx = preferencesSrc.indexOf('case "quality":');
+  const qualityEnd = preferencesSrc.indexOf("}", qualityIdx + 50);
+  // Look for the return block after case "quality":
+  const qualityReturn = preferencesSrc.slice(qualityIdx, qualityIdx + 200);
+  assert.ok(
+    qualityReturn.includes("phases: {}"),
+    "quality should have empty phases object (no skips)",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Default Behavior (D046)
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("profile: resolveEffectiveProfile defaults to balanced (D046)", () => {
+  assert.ok(
+    preferencesSrc.includes("export function resolveEffectiveProfile"),
+    "resolveEffectiveProfile should be exported",
+  );
+  assert.ok(
+    preferencesSrc.includes('return "balanced"'),
+    "resolveEffectiveProfile should default to balanced",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Inline Level Mapping
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("profile: resolveInlineLevel maps profile to inline level", () => {
+  assert.ok(
+    preferencesSrc.includes("export function resolveInlineLevel"),
+    "resolveInlineLevel should be exported",
+  );
+  assert.ok(preferencesSrc.includes('case "budget": return "minimal"'), "budget → minimal");
+  assert.ok(preferencesSrc.includes('case "balanced": return "standard"'), "balanced → standard");
+  assert.ok(preferencesSrc.includes('case "quality": return "full"'), "quality → full");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Validation
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("validate: validatePreferences handles token_profile", () => {
+  assert.ok(
+    preferencesSrc.includes("preferences.token_profile") &&
+    preferencesSrc.includes("budget, balanced, quality"),
+    "validatePreferences should validate token_profile enum values",
+  );
+});
+
+test("validate: validatePreferences handles phases object", () => {
+  assert.ok(
+    preferencesSrc.includes("preferences.phases") &&
+    preferencesSrc.includes("skip_research") &&
+    preferencesSrc.includes("skip_reassess") &&
+    preferencesSrc.includes("skip_slice_research"),
+    "validatePreferences should validate phases fields",
+  );
+});
+
+test("validate: phases warns on unknown keys", () => {
+  assert.ok(
+    preferencesSrc.includes("knownPhaseKeys") &&
+    preferencesSrc.includes("unknown phases key"),
+    "validatePreferences should warn on unknown phase keys",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Merge
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("merge: mergePreferences handles token_profile with nullish coalescing", () => {
+  assert.ok(
+    preferencesSrc.includes("token_profile: override.token_profile ?? base.token_profile"),
+    "mergePreferences should use nullish coalescing for token_profile",
+  );
+});
+
+test("merge: mergePreferences handles phases with spread", () => {
+  assert.ok(
+    preferencesSrc.includes("...(base.phases") && preferencesSrc.includes("...(override.phases"),
+    "mergePreferences should spread phases objects",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Subagent Model Routing
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("subagent: budget profile sets subagent model", () => {
+  const budgetIdx = preferencesSrc.indexOf('case "budget":');
+  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
+  const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
+  assert.ok(budgetBlock.includes("subagent:"), "budget profile should set subagent model");
+});
+
+test("subagent: resolveModelWithFallbacksForUnit handles subagent unit types", () => {
+  assert.ok(
+    preferencesSrc.includes('"subagent"') && preferencesSrc.includes('startsWith("subagent/")'),
+    "resolveModelWithFallbacksForUnit should handle subagent and subagent/* unit types",
+  );
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Dispatch Table — Phase Skip Guards
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("dispatch: research-milestone rule has skip_research guard", () => {
+  // Find the research-milestone rule and check it has the guard
+  const ruleIdx = dispatchSrc.indexOf("research-milestone");
+  assert.ok(ruleIdx > -1, "should have research-milestone rule");
+  // The guard should appear near this rule
+  assert.ok(
+    dispatchSrc.includes("skip_research") && dispatchSrc.includes("research-milestone"),
+    "research-milestone dispatch rule should check phases.skip_research",
+  );
+});
+
+test("dispatch: research-slice rule has skip guards", () => {
+  const ruleIdx = dispatchSrc.indexOf("research-slice");
+  assert.ok(ruleIdx > -1, "should have research-slice rule");
+  const afterRule = dispatchSrc.slice(ruleIdx);
+  assert.ok(
+    afterRule.includes("skip_research") || afterRule.includes("skip_slice_research"),
+    "research-slice rule should check skip_research or skip_slice_research",
+  );
+});
+
+test("dispatch: reassess-roadmap rule has skip_reassess guard", () => {
+  assert.ok(
+    dispatchSrc.includes("skip_reassess") && dispatchSrc.includes("reassess-roadmap"),
+    "reassess-roadmap dispatch rule should check phases.skip_reassess",
+  );
+});
+
+test("dispatch: phase skip guards return null (not stop)", () => {
+  // Verify skip guards use return null pattern
+  const researchGuard = dispatchSrc.match(/skip_research\).*?return null/s);
+  assert.ok(researchGuard, "skip_research guard should return null (fall-through)");
+
+  const reassessGuard = dispatchSrc.match(/skip_reassess\).*?return null/s);
+  assert.ok(reassessGuard, "skip_reassess guard should return null (fall-through)");
+});

package/dist/resources/extensions/gsd/types.ts

@@ -238,6 +238,34 @@ export interface HookDispatchResult {
 
 export type BudgetEnforcementMode = 'warn' | 'pause' | 'halt';
 
+export type TokenProfile = 'budget' | 'balanced' | 'quality';
+
+export type InlineLevel = 'full' | 'standard' | 'minimal';
+
+export type ComplexityTier = 'light' | 'standard' | 'heavy';
+
+export interface ClassificationResult {
+  tier: ComplexityTier;
+  reason: string;
+  downgraded: boolean;
+}
+
+export interface TaskMetadata {
+  fileCount?: number;
+  dependencyCount?: number;
+  isNewFile?: boolean;
+  tags?: string[];
+  estimatedLines?: number;
+  codeBlockCount?: number;
+  complexityKeywords?: string[];
+}
+
+export interface PhaseSkipPreferences {
+  skip_research?: boolean;
+  skip_reassess?: boolean;
+  skip_slice_research?: boolean;
+}
+
 export interface NotificationPreferences {
   enabled?: boolean;           // default true
   on_complete?: boolean;       // notify on each unit completion

package/dist/resources/extensions/gsd/worktree-manager.ts

@@ -94,7 +94,7 @@ export function worktreeBranchName(name: string): string {
  *
  * @param opts.branch — override the default `worktree/<name>` branch name
  */
-export function createWorktree(basePath: string, name: string, opts: { branch?: string } = {}): WorktreeInfo {
+export function createWorktree(basePath: string, name: string, opts: { branch?: string; startPoint?: string } = {}): WorktreeInfo {
   // Validate name: alphanumeric, hyphens, underscores only
   if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
     throw new Error(`Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
@@ -114,9 +114,12 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
   // Prune any stale worktree entries from a previous removal
   nativeWorktreePrune(basePath);
 
+  // Use the explicit start point (e.g. integration branch) if provided,
+  // otherwise fall back to the repo's detected main branch.
+  const startPoint = opts.startPoint ?? nativeDetectMainBranch(basePath);
+
   // Check if the branch already exists (leftover from a previous worktree)
   const branchAlreadyExists = nativeBranchExists(basePath, branch);
-  const mainBranch = nativeDetectMainBranch(basePath);
 
   if (branchAlreadyExists) {
     // Check if the branch is actively used by an existing worktree.
@@ -130,11 +133,11 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
       );
     }
 
-    // Reset the stale branch to current main, then attach worktree to it
-    nativeBranchForceReset(basePath, branch, mainBranch);
+    // Reset the stale branch to the start point, then attach worktree to it
+    nativeBranchForceReset(basePath, branch, startPoint);
     nativeWorktreeAdd(basePath, wtPath, branch);
   } else {
-    nativeWorktreeAdd(basePath, wtPath, branch, true, mainBranch);
+    nativeWorktreeAdd(basePath, wtPath, branch, true, startPoint);
   }
 
   return {

package/dist/resources/extensions/gsd/worktree.ts

@@ -54,10 +54,10 @@ export function setActiveMilestoneId(basePath: string, milestoneId: string | nul
  * record when the user starts from a different branch (#300). Always a no-op
  * if on a GSD slice branch.
  */
-export function captureIntegrationBranch(basePath: string, milestoneId: string): void {
+export function captureIntegrationBranch(basePath: string, milestoneId: string, options?: { commitDocs?: boolean }): void {
   const svc = getService(basePath);
   const current = svc.getCurrentBranch();
-  writeIntegrationBranch(basePath, milestoneId, current);
+  writeIntegrationBranch(basePath, milestoneId, current, options);
 }
 
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
@@ -76,6 +76,28 @@ export function detectWorktreeName(basePath: string): string | null {
   return name || null;
 }
 
+/**
+ * Resolve the project root from a path that may be inside a worktree.
+ * If the path contains `/.gsd/worktrees/<name>/`, returns the portion
+ * before `/.gsd/`. Otherwise returns the input unchanged.
+ *
+ * Use this in commands that call `process.cwd()` to ensure they always
+ * operate against the real project root, not a worktree subdirectory.
+ */
+export function resolveProjectRoot(basePath: string): string {
+  const normalizedPath = basePath.replaceAll("\\", "/");
+  const marker = "/.gsd/worktrees/";
+  const idx = normalizedPath.indexOf(marker);
+  if (idx === -1) return basePath;
+  // Return the original path up to the .gsd/ marker (un-normalized)
+  // Account for potential OS-specific separators
+  const sep = basePath.includes("\\") ? "\\" : "/";
+  const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
+  const idxOs = basePath.indexOf(markerOs);
+  if (idxOs !== -1) return basePath.slice(0, idxOs);
+  return basePath.slice(0, idx);
+}
+
 /**
  * Get the slice branch name, namespaced by worktree when inside one.
  *

package/dist/resources/extensions/shared/next-action-ui.ts

@@ -118,7 +118,7 @@ export async function showNextAction(
 		}
 	});
 
-	return ctx.ui.custom<string>((_tui: TUI, theme: Theme, _kb, done) => {
+	const result = await ctx.ui.custom<string>((_tui: TUI, theme: Theme, _kb, done) => {
 		let cursorIdx = defaultIdx;
 		let cachedLines: string[] | undefined;
 
@@ -194,4 +194,19 @@ export async function showNextAction(
 
 		return { render, invalidate: () => { cachedLines = undefined; }, handleInput };
 	});
+
+	// Fallback for RPC mode where ctx.ui.custom() returns undefined (#447).
+	// Fall back to ctx.ui.select() which IS implemented in RPC mode.
+	if (result === undefined || result === null) {
+		const labels = allActions.map(a => {
+			const tag = a.recommended ? " (recommended)" : "";
+			return `${a.label}${tag}: ${a.description}`;
+		});
+		const selected = await ctx.ui.select(opts.title, labels);
+		if (selected === undefined || selected === null) return "not_yet";
+		const idx = labels.indexOf(selected as string);
+		return idx >= 0 ? allActions[idx].id : "not_yet";
+	}
+
+	return result;
 }

package/package.json

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