gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

package/dist/resources/extensions/gsd/tests/write-gate.test.ts

@@ -1,211 +0,0 @@
-/**
- * Unit tests for the CONTEXT.md write-gate.
- *
- * Exercises shouldBlockContextWrite() — a pure function that implements:
- *   (a) toolName !== "write" → pass
- *   (b) milestoneId null AND no queue phase → pass (not in any flow)
- *   (c) path doesn't match /M\d+-CONTEXT\.md$/ → pass
- *   (d) depthVerified → pass (backward compat for discussion flows)
- *   (e) queuePhaseActive + per-milestone verified → pass
- *   (f) queuePhaseActive + not verified → block
- *   (g) else → block with actionable reason
- *
- * Also exercises per-milestone verification helpers:
- *   markDepthVerified(), isDepthVerifiedFor()
- */
-
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  shouldBlockContextWrite,
-  markDepthVerified,
-  isDepthVerifiedFor,
-  isDepthVerified,
-} from '../index.ts';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Discussion flow tests (backward compatibility)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: blocks CONTEXT.md write during discussion without depth verification (absolute path)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '/Users/dev/project/.gsd/milestones/M001/M001-CONTEXT.md',
-    'M001',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should block the write');
-  assert.ok(result.reason, 'should provide a reason');
-});
-
-test('write-gate: blocks CONTEXT.md write during discussion without depth verification (relative path)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M005/M005-CONTEXT.md',
-    'M005',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should block the write');
-  assert.ok(result.reason, 'should provide a reason');
-});
-
-test('write-gate: allows CONTEXT.md write after depth verification (discussion flow)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '/Users/dev/project/.gsd/milestones/M001/M001-CONTEXT.md',
-    'M001',
-    true,
-  );
-  assert.strictEqual(result.block, false, 'should not block after depth verification');
-  assert.strictEqual(result.reason, undefined, 'should have no reason');
-});
-
-test('write-gate: allows CONTEXT.md write outside any flow (milestoneId null, no queue)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M001/M001-CONTEXT.md',
-    null,
-    false,
-    false,
-  );
-  assert.strictEqual(result.block, false, 'should not block outside any flow');
-});
-
-test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
-  const r1 = shouldBlockContextWrite('write', '.gsd/milestones/M001/M001-DISCUSSION.md', 'M001', false);
-  assert.strictEqual(r1.block, false, 'DISCUSSION.md should pass');
-
-  const r2 = shouldBlockContextWrite('write', '.gsd/milestones/M001/slices/S01/S01-PLAN.md', 'M001', false);
-  assert.strictEqual(r2.block, false, 'slice plan should pass');
-
-  const r3 = shouldBlockContextWrite('write', 'src/index.ts', 'M001', false);
-  assert.strictEqual(r3.block, false, 'regular code file should pass');
-});
-
-test('write-gate: regex does not match slice context files (S01-CONTEXT.md)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M001/slices/S01/S01-CONTEXT.md',
-    'M001',
-    false,
-  );
-  assert.strictEqual(result.block, false, 'S01-CONTEXT.md should not be blocked');
-});
-
-test('write-gate: blocked reason contains actionable instructions', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M999/M999-CONTEXT.md',
-    'M999',
-    false,
-  );
-  assert.strictEqual(result.block, true);
-  assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification');
-  assert.ok(result.reason!.includes('ask_user_questions'), 'reason should mention ask_user_questions');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Queue flow tests (NEW — enforces write-gate during /gsd queue)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: blocks CONTEXT.md write during queue flow without verification', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    null,  // queue flows have no pendingAutoStart → milestoneId is null
-    false,
-    true,  // but queuePhaseActive is true
-  );
-  assert.strictEqual(result.block, true, 'should block during queue flow without verification');
-  assert.ok(result.reason!.includes('multi-milestone'), 'reason should mention multi-milestone');
-});
-
-test('write-gate: allows CONTEXT.md write during queue flow AFTER per-milestone verification', () => {
-  // Simulate: depth_verification_M010-3ym37m was answered
-  markDepthVerified('M010-3ym37m');
-
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(result.block, false, 'should allow after per-milestone verification');
-});
-
-test('write-gate: blocks DIFFERENT milestone in queue flow when only one is verified', () => {
-  // M010-3ym37m was verified above, but M011-rfmd3q was NOT
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M011-rfmd3q/M011-rfmd3q-CONTEXT.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(result.block, true, 'should block unverified milestone even when another is verified');
-});
-
-test('write-gate: wildcard verification unlocks all milestones in queue flow', () => {
-  markDepthVerified('*');
-
-  const r1 = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M099/M099-CONTEXT.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(r1.block, false, 'wildcard should pass any milestone');
-});
-
-test('write-gate: allows non-CONTEXT.md writes during queue flow regardless', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/QUEUE.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(result.block, false, 'QUEUE.md should pass during queue flow');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Unique milestone ID format tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: matches unique milestone ID format (M010-3ym37m)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    'M010-3ym37m',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should match unique milestone ID format');
-});
-
-test('write-gate: matches classic milestone ID format (M001)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M001/M001-CONTEXT.md',
-    'M001',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should match classic milestone ID format');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Per-milestone depth verification helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('isDepthVerifiedFor: returns false for unknown milestone', () => {
-  assert.strictEqual(isDepthVerifiedFor('M999-xxxxxx'), true,
-    'returns true because wildcard * was set in earlier test');
-  // Note: test isolation would require clearing state, but these tests
-  // exercise the module as a singleton (matching production behavior)
-});
-
-test('isDepthVerified: returns true when any milestone verified', () => {
-  // At this point M010-3ym37m and * are verified from earlier tests
-  assert.strictEqual(isDepthVerified(), true);
-});

package/dist/resources/extensions/gsd/token-counter.ts

@@ -1,65 +0,0 @@
-export type TokenProvider = "anthropic" | "openai" | "google" | "mistral" | "bedrock" | "unknown";
-
-const CHARS_PER_TOKEN_BY_PROVIDER: Record<TokenProvider, number> = {
-	anthropic: 3.5,
-	openai: 4.0,
-	google: 4.0,
-	mistral: 3.8,
-	bedrock: 3.5,
-	unknown: 4.0,
-};
-
-interface TokenEncoder {
-	encode(text: string): Uint32Array | number[];
-}
-
-let encoder: TokenEncoder | null = null;
-let encoderFailed = false;
-
-async function getEncoder(): Promise<TokenEncoder | null> {
-	if (encoder) return encoder;
-	if (encoderFailed) return null;
-	try {
-		// @ts-ignore — tiktoken may not have type declarations in extensions tsconfig
-		const tiktoken = await import("tiktoken");
-		encoder = tiktoken.encoding_for_model("gpt-4o") as TokenEncoder;
-		return encoder;
-	} catch {
-		encoderFailed = true;
-		return null;
-	}
-}
-
-export async function countTokens(text: string): Promise<number> {
-	const enc = await getEncoder();
-	if (enc) {
-		const tokens = enc.encode(text);
-		return tokens.length;
-	}
-	return Math.ceil(text.length / 4);
-}
-
-export function countTokensSync(text: string): number {
-	if (encoder) {
-		return encoder.encode(text).length;
-	}
-	return Math.ceil(text.length / 4);
-}
-
-export async function initTokenCounter(): Promise<boolean> {
-	const enc = await getEncoder();
-	return enc !== null;
-}
-
-export function isAccurateCountingAvailable(): boolean {
-	return encoder !== null;
-}
-
-export function getCharsPerToken(provider: TokenProvider): number {
-	return CHARS_PER_TOKEN_BY_PROVIDER[provider] ?? CHARS_PER_TOKEN_BY_PROVIDER.unknown;
-}
-
-export function estimateTokensForProvider(text: string, provider: TokenProvider): number {
-	const ratio = getCharsPerToken(provider);
-	return Math.ceil(text.length / ratio);
-}

package/dist/resources/extensions/gsd/triage-resolution.ts

@@ -1,284 +0,0 @@
-/**
- * GSD Triage Resolution — Execute triage classifications
- *
- * Provides resolution executors for each capture classification type:
- *
- * - inject: appends a new task to the current slice plan
- * - replan: writes REPLAN-TRIGGER.md so next dispatchNextUnit enters replanning-slice
- * - defer/note: query helpers for loading deferred/replan captures
- *
- * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
- */
-
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import type { Classification, CaptureEntry } from "./captures.js";
-import {
-  loadPendingCaptures,
-  loadAllCaptures,
-  loadActionableCaptures,
-  markCaptureResolved,
-  markCaptureExecuted,
-} from "./captures.js";
-
-// ─── Resolution Executors ─────────────────────────────────────────────────────
-
-/**
- * Inject a new task into the current slice plan.
- * Reads the plan, finds the highest task ID, appends a new task entry.
- * Returns the new task ID, or null if injection failed.
- */
-export function executeInject(
-  basePath: string,
-  mid: string,
-  sid: string,
-  capture: CaptureEntry,
-): string | null {
-  try {
-    // Resolve the plan file path
-    const planPath = join(gsdRoot(basePath), "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
-    if (!existsSync(planPath)) return null;
-
-    const content = readFileSync(planPath, "utf-8");
-
-    // Find the highest existing task ID
-    const taskMatches = [...content.matchAll(/- \[[ x]\] \*\*T(\d+):/g)];
-    if (taskMatches.length === 0) return null;
-
-    const maxId = Math.max(...taskMatches.map(m => parseInt(m[1], 10)));
-    const newId = `T${String(maxId + 1).padStart(2, "0")}`;
-
-    // Build the new task entry
-    const newTask = [
-      `- [ ] **${newId}: ${capture.text}** \`est:30m\``,
-      `  - Why: Injected from capture ${capture.id} during triage`,
-      `  - Do: ${capture.text}`,
-      `  - Done when: Capture intent fulfilled`,
-    ].join("\n");
-
-    // Find the last task entry and append after it
-    // Look for the "## Files Likely Touched" section as the boundary
-    const filesSection = content.indexOf("## Files Likely Touched");
-    if (filesSection !== -1) {
-      const updated = content.slice(0, filesSection) + newTask + "\n\n" + content.slice(filesSection);
-      writeFileSync(planPath, updated, "utf-8");
-    } else {
-      // No Files section — append at end
-      writeFileSync(planPath, content.trimEnd() + "\n\n" + newTask + "\n", "utf-8");
-    }
-
-    return newId;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Trigger replanning by writing a REPLAN-TRIGGER.md marker file.
- * The existing state.ts derivation detects this and sets phase to "replanning-slice".
- * Returns true if the trigger was written successfully.
- */
-export function executeReplan(
-  basePath: string,
-  mid: string,
-  sid: string,
-  capture: CaptureEntry,
-): boolean {
-  try {
-    const triggerPath = join(
-      basePath, ".gsd", "milestones", mid, "slices", sid, `${sid}-REPLAN-TRIGGER.md`,
-    );
-    const content = [
-      `# Replan Trigger`,
-      ``,
-      `**Source:** Capture ${capture.id}`,
-      `**Capture:** ${capture.text}`,
-      `**Rationale:** ${capture.rationale ?? "User-initiated replan via capture triage"}`,
-      `**Triggered:** ${new Date().toISOString()}`,
-      ``,
-      `This file was created by the triage pipeline. The next dispatch cycle`,
-      `will detect it and enter the replanning-slice phase.`,
-    ].join("\n");
-
-    writeFileSync(triggerPath, content, "utf-8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ─── File Overlap Detection ───────────────────────────────────────────────────
-
-/**
- * Detect file overlap between a capture's affected files and planned tasks.
- *
- * Parses the slice plan for task file references and returns task IDs
- * whose files overlap with the capture's affected files.
- *
- * @param affectedFiles - Files the capture would touch
- * @param planContent - Content of the slice plan.md
- * @returns Array of task IDs (e.g., ["T03", "T04"]) whose files overlap
- */
-export function detectFileOverlap(
-  affectedFiles: string[],
-  planContent: string,
-): string[] {
-  if (!affectedFiles || affectedFiles.length === 0) return [];
-
-  const overlappingTasks: string[] = [];
-
-  // Normalize affected files for comparison
-  const normalizedAffected = new Set(
-    affectedFiles.map(f => f.replace(/^\.\//, "").toLowerCase()),
-  );
-
-  // Parse plan for incomplete tasks and their file references
-  const taskPattern = /- \[ \] \*\*(T\d+):[^*]*\*\*/g;
-  const tasks = [...planContent.matchAll(taskPattern)];
-
-  for (const taskMatch of tasks) {
-    const taskId = taskMatch[1];
-    const taskStart = taskMatch.index!;
-
-    // Find the end of this task (next task or end of section)
-    const nextTask = planContent.indexOf("- [", taskStart + 1);
-    const sectionEnd = planContent.indexOf("##", taskStart + 1);
-    const taskEnd = Math.min(
-      nextTask === -1 ? planContent.length : nextTask,
-      sectionEnd === -1 ? planContent.length : sectionEnd,
-    );
-
-    const taskContent = planContent.slice(taskStart, taskEnd);
-
-    // Extract file references — look for backtick-quoted paths
-    const fileRefs = [...taskContent.matchAll(/`([^`]+\.[a-z]+)`/g)]
-      .map(m => m[1].replace(/^\.\//, "").toLowerCase());
-
-    // Check for overlap
-    const hasOverlap = fileRefs.some(f => normalizedAffected.has(f));
-    if (hasOverlap) {
-      overlappingTasks.push(taskId);
-    }
-  }
-
-  return overlappingTasks;
-}
-
-/**
- * Load deferred captures (classification === "defer") for injection into
- * reassess-roadmap prompts.
- */
-export function loadDeferredCaptures(basePath: string): CaptureEntry[] {
-  return loadAllCaptures(basePath).filter(c => c.classification === "defer");
-}
-
-/**
- * Load replan-triggering captures for injection into replan-slice prompts.
- */
-export function loadReplanCaptures(basePath: string): CaptureEntry[] {
-  return loadAllCaptures(basePath).filter(c => c.classification === "replan");
-}
-
-/**
- * Build a quick-task execution prompt from a capture.
- */
-export function buildQuickTaskPrompt(capture: CaptureEntry): string {
-  return [
-    `You are executing a quick one-off task captured during a GSD auto-mode session.`,
-    ``,
-    `## Quick Task`,
-    ``,
-    `**Capture ID:** ${capture.id}`,
-    `**Task:** ${capture.text}`,
-    ``,
-    `## Instructions`,
-    ``,
-    `1. Execute this task as a small, self-contained change.`,
-    `2. Do NOT modify any \`.gsd/\` plan files — this is a one-off, not a planned task.`,
-    `3. Commit your changes with a descriptive message.`,
-    `4. Keep changes minimal and focused on the capture text.`,
-    `5. When done, say: "Quick task complete."`,
-  ].join("\n");
-}
-
-// ─── Post-Triage Resolution Executor ─────────────────────────────────────────
-
-/**
- * Result of executing triage resolutions after a triage-captures unit completes.
- */
-export interface TriageExecutionResult {
-  /** Number of inject resolutions executed (tasks added to plan) */
-  injected: number;
-  /** Number of replan triggers written */
-  replanned: number;
-  /** Captures classified as quick-task that need dispatch */
-  quickTasks: CaptureEntry[];
-  /** Details of each action taken, for logging */
-  actions: string[];
-}
-
-/**
- * Execute pending triage resolutions.
- *
- * Called after a triage-captures unit completes. Reads CAPTURES.md for
- * resolved captures that have actionable classifications (inject, replan,
- * quick-task) but haven't been executed yet, then:
- *
- * - inject: calls executeInject() to add a task to the current slice plan
- * - replan: calls executeReplan() to write the REPLAN-TRIGGER.md marker
- * - quick-task: collects for dispatch (caller handles dispatching quick-task units)
- *
- * Each capture is marked as executed after its resolution action succeeds,
- * preventing double-execution on retries or restarts.
- */
-export function executeTriageResolutions(
-  basePath: string,
-  mid: string,
-  sid: string,
-): TriageExecutionResult {
-  const result: TriageExecutionResult = {
-    injected: 0,
-    replanned: 0,
-    quickTasks: [],
-    actions: [],
-  };
-
-  const actionable = loadActionableCaptures(basePath);
-  if (actionable.length === 0) return result;
-
-  for (const capture of actionable) {
-    switch (capture.classification) {
-      case "inject": {
-        const newTaskId = executeInject(basePath, mid, sid, capture);
-        if (newTaskId) {
-          markCaptureExecuted(basePath, capture.id);
-          result.injected++;
-          result.actions.push(`Injected ${newTaskId} from ${capture.id}: "${capture.text}"`);
-        } else {
-          result.actions.push(`Failed to inject ${capture.id}: "${capture.text}" (no plan file or parse error)`);
-        }
-        break;
-      }
-      case "replan": {
-        const success = executeReplan(basePath, mid, sid, capture);
-        if (success) {
-          markCaptureExecuted(basePath, capture.id);
-          result.replanned++;
-          result.actions.push(`Replan triggered from ${capture.id}: "${capture.text}"`);
-        } else {
-          result.actions.push(`Failed to trigger replan from ${capture.id}: "${capture.text}"`);
-        }
-        break;
-      }
-      case "quick-task": {
-        // Quick-tasks are collected for dispatch, not executed inline
-        result.quickTasks.push(capture);
-        result.actions.push(`Quick-task queued from ${capture.id}: "${capture.text}"`);
-        break;
-      }
-    }
-  }
-
-  return result;
-}