@opengsd/get-shit-done-redux 1.0.0

package/sdk/src/sdk-package-compatibility.ts

@@ -0,0 +1,141 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { GSDError, ErrorClassification } from './errors.js';
+
+export type LegacySdkAsset = 'gsd-tools' | 'core-cjs';
+
+export interface LegacySdkAssetResolution {
+  asset: LegacySdkAsset;
+  path: string | null;
+  fallbackPath: string;
+  probes: string[];
+}
+
+interface LegacySdkCompatibilityDeps {
+  existsSync?: (path: string) => boolean;
+  homeDir?: string;
+  createRequire?: typeof createRequire;
+}
+
+export const BUNDLED_GSD_TOOLS_PATH = fileURLToPath(
+  new URL('../../get-shit-done/bin/gsd-tools.cjs', import.meta.url),
+);
+
+export const BUNDLED_CORE_CJS_PATH = fileURLToPath(
+  new URL('../../get-shit-done/bin/lib/core.cjs', import.meta.url),
+);
+
+export const BUNDLED_GSD_TEMPLATES_DIR = fileURLToPath(
+  new URL('../../get-shit-done/templates', import.meta.url),
+);
+
+export const BUNDLED_GSD_AGENTS_DIR = fileURLToPath(
+  new URL('../../agents', import.meta.url),
+);
+
+const LEGACY_ASSET_SUBPATH: Record<LegacySdkAsset, string> = {
+  'gsd-tools': 'gsd-tools.cjs',
+  'core-cjs': join('lib', 'core.cjs'),
+};
+
+const BUNDLED_LEGACY_ASSET_PATH: Record<LegacySdkAsset, string> = {
+  'gsd-tools': BUNDLED_GSD_TOOLS_PATH,
+  'core-cjs': BUNDLED_CORE_CJS_PATH,
+};
+
+export function resolveLegacyInstallDir(homeDir: string = homedir()): string {
+  return join(homeDir, '.claude', 'get-shit-done');
+}
+
+export function resolveLegacyTemplatesDir(homeDir: string = homedir()): string {
+  return join(resolveLegacyInstallDir(homeDir), 'templates');
+}
+
+export function resolveLegacyWorkflowsDir(homeDir: string = homedir()): string {
+  return join(resolveLegacyInstallDir(homeDir), 'workflows');
+}
+
+export function resolveLegacyUserProfilePath(homeDir: string = homedir()): string {
+  return join(resolveLegacyInstallDir(homeDir), 'USER-PROFILE.md');
+}
+
+export function resolveLegacySkillsDir(homeDir: string = homedir()): string {
+  return join(resolveLegacyInstallDir(homeDir), 'skills');
+}
+
+export function resolveBundledTemplatesDir(): string {
+  return BUNDLED_GSD_TEMPLATES_DIR;
+}
+
+export function resolveBundledAgentsDir(): string {
+  return BUNDLED_GSD_AGENTS_DIR;
+}
+
+function legacyAssetProbes(asset: LegacySdkAsset, projectDir: string, homeDir: string): string[] {
+  const suffix = LEGACY_ASSET_SUBPATH[asset];
+  return [
+    BUNDLED_LEGACY_ASSET_PATH[asset],
+    join(projectDir, '.claude', 'get-shit-done', 'bin', suffix),
+    join(homeDir, '.claude', 'get-shit-done', 'bin', suffix),
+  ];
+}
+
+export function probeLegacySdkAsset(
+  asset: LegacySdkAsset,
+  projectDir: string,
+  deps: LegacySdkCompatibilityDeps = {},
+): LegacySdkAssetResolution {
+  const pathExists = deps.existsSync ?? existsSync;
+  const probes = legacyAssetProbes(asset, projectDir, deps.homeDir ?? homedir());
+  return {
+    asset,
+    path: probes.find(candidate => pathExists(candidate)) ?? null,
+    fallbackPath: probes[probes.length - 1]!,
+    probes,
+  };
+}
+
+/**
+ * Resolve the legacy `gsd-tools.cjs` executable path through the SDK Package Seam Module.
+ *
+ * Preserves historical behavior: if no probe exists, return the final fallback path so
+ * downstream subprocess errors still show a concrete location.
+ */
+export function resolveGsdToolsPath(projectDir: string, deps: LegacySdkCompatibilityDeps = {}): string {
+  const resolution = probeLegacySdkAsset('gsd-tools', projectDir, deps);
+  return resolution.path ?? resolution.fallbackPath;
+}
+
+function missingLegacyCoreMessage(resolution: LegacySdkAssetResolution): string {
+  return [
+    'state load: get-shit-done/bin/lib/core.cjs not found.',
+    `Checked: ${resolution.probes.join(', ')}`,
+    'Install GSD (e.g. npm i -g @opengsd/get-shit-done-redux) or clone with get-shit-done next to the SDK.',
+  ].join(' ');
+}
+
+/**
+ * Load `loadConfig(cwd)` from the legacy CJS install through one compatibility seam.
+ */
+export function loadLegacyCoreConfig(projectDir: string, deps: LegacySdkCompatibilityDeps = {}): Record<string, unknown> {
+  const resolution = probeLegacySdkAsset('core-cjs', projectDir, deps);
+  if (!resolution.path) {
+    throw new GSDError(
+      missingLegacyCoreMessage(resolution),
+      ErrorClassification.Blocked,
+    );
+  }
+
+  const req = (deps.createRequire ?? createRequire)(import.meta.url);
+  const mod = req(resolution.path) as Partial<{ loadConfig: (cwd: string) => Record<string, unknown> }>;
+  if (typeof mod.loadConfig !== 'function') {
+    throw new GSDError(
+      `state load: invalid core.cjs at ${resolution.path} (missing loadConfig(cwd)).`,
+      ErrorClassification.Blocked,
+    );
+  }
+  return mod.loadConfig(projectDir);
+}

package/sdk/src/session-runner.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Unit tests for session-runner.ts
+ *
+ * Regression test for #2194: runPhaseStepSession was passing the full prompt
+ * string as both the user-visible prompt: message and systemPrompt.append,
+ * doubling the token cost on every phase step invocation.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PhaseStepType } from './types.js';
+import { CONFIG_DEFAULTS } from './config.js';
+import type { GSDConfig } from './config.js';
+
+// ─── Mock the Agent SDK ───────────────────────────────────────────────────────
+
+// Capture the query call options so we can assert on them without making real API calls.
+const mockQueryCalls: Array<{ prompt: string; options: Record<string, unknown> }> = [];
+
+vi.mock('@anthropic-ai/claude-agent-sdk', () => {
+  async function* fakeQueryStream() {
+    // Yield a minimal success result message so processQueryStream completes.
+    yield {
+      type: 'result',
+      subtype: 'success',
+      session_id: 'test-session',
+      total_cost_usd: 0,
+      duration_ms: 1,
+      num_turns: 1,
+      usage: {
+        input_tokens: 10,
+        output_tokens: 5,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+      },
+    };
+  }
+
+  return {
+    query: vi.fn((args: { prompt: string; options: Record<string, unknown> }) => {
+      mockQueryCalls.push({ prompt: args.prompt, options: args.options });
+      return fakeQueryStream();
+    }),
+  };
+});
+
+// ─── Import SUT after mock is hoisted ────────────────────────────────────────
+
+import { runPhaseStepSession } from './session-runner.js';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeConfig(overrides: Partial<GSDConfig> = {}): GSDConfig {
+  return { ...CONFIG_DEFAULTS, ...overrides };
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('runPhaseStepSession', () => {
+  beforeEach(() => {
+    mockQueryCalls.length = 0;
+  });
+
+  it('does not duplicate the prompt in both the user message and systemPrompt.append', async () => {
+    const fullPrompt = 'You are a researcher. Investigate the topic thoroughly.\n\n## Context\nDetailed instructions here...';
+
+    await runPhaseStepSession(fullPrompt, PhaseStepType.Research, makeConfig());
+
+    expect(mockQueryCalls).toHaveLength(1);
+
+    const call = mockQueryCalls[0];
+    const appendValue = (call.options.systemPrompt as { append?: string })?.append;
+
+    // The full prompt must appear in systemPrompt.append (that is its correct location).
+    expect(appendValue).toBe(fullPrompt);
+
+    // The user-visible prompt: must NOT be the full prompt — it should be a short directive.
+    expect(call.prompt).not.toBe(fullPrompt);
+    expect(call.prompt.length).toBeLessThan(fullPrompt.length);
+  });
+
+  it('passes the full prompt in systemPrompt.append', async () => {
+    const fullPrompt = 'Complex multi-line\nprompt with $VARIABLES and $(command) patterns.';
+
+    await runPhaseStepSession(fullPrompt, PhaseStepType.Execute, makeConfig());
+
+    const call = mockQueryCalls[0];
+    const appendValue = (call.options.systemPrompt as { append?: string })?.append;
+
+    expect(appendValue).toBe(fullPrompt);
+  });
+
+  it('returns a successful PlanResult', async () => {
+    const result = await runPhaseStepSession('Test prompt', PhaseStepType.Verify, makeConfig());
+
+    expect(result.success).toBe(true);
+    expect(result.sessionId).toBe('test-session');
+  });
+
+  // ─── #2832: runtime-aware model resolution ─────────────────────────────────
+  // Issue: with `runtime: codex` and `model_profile: balanced`, resolveModel
+  // mapped balanced -> 'claude-sonnet-4-6' and forced the Codex run through
+  // a Claude model. For non-Claude runtimes the SDK must NOT inject a Claude
+  // model id; it should leave model unset (or honor explicit overrides) and
+  // let the runtime use its configured default.
+  describe('resolveModel runtime awareness (#2832)', () => {
+    it('does NOT pass a Claude profile model id when runtime is codex', async () => {
+      await runPhaseStepSession(
+        'prompt',
+        PhaseStepType.Execute,
+        makeConfig({ runtime: 'codex', model_profile: 'balanced' } as Partial<GSDConfig>),
+      );
+      const opts = mockQueryCalls[0].options as { model?: string };
+      expect(opts.model).toBeUndefined();
+    });
+
+    it('does NOT pass a Claude profile model id when resolve_model_ids is "omit"', async () => {
+      await runPhaseStepSession(
+        'prompt',
+        PhaseStepType.Execute,
+        makeConfig({ resolve_model_ids: 'omit', model_profile: 'balanced' } as Partial<GSDConfig>),
+      );
+      const opts = mockQueryCalls[0].options as { model?: string };
+      expect(opts.model).toBeUndefined();
+    });
+
+    it('still maps profile -> Claude id when runtime is claude (no regression)', async () => {
+      await runPhaseStepSession(
+        'prompt',
+        PhaseStepType.Execute,
+        makeConfig({ runtime: 'claude', model_profile: 'balanced' } as Partial<GSDConfig>),
+      );
+      const opts = mockQueryCalls[0].options as { model?: string };
+      expect(opts.model).toBe('claude-sonnet-4-6');
+    });
+
+    it('respects GSD_RUNTIME env precedence over config (no Claude id when env=codex)', async () => {
+      const prev = process.env.GSD_RUNTIME;
+      process.env.GSD_RUNTIME = 'codex';
+      try {
+        await runPhaseStepSession(
+          'prompt',
+          PhaseStepType.Execute,
+          makeConfig({ model_profile: 'balanced' } as Partial<GSDConfig>),
+        );
+        const opts = mockQueryCalls[0].options as { model?: string };
+        expect(opts.model).toBeUndefined();
+      } finally {
+        if (prev === undefined) delete process.env.GSD_RUNTIME;
+        else process.env.GSD_RUNTIME = prev;
+      }
+    });
+
+    it('explicit options.model wins for any runtime', async () => {
+      await runPhaseStepSession(
+        'prompt',
+        PhaseStepType.Execute,
+        makeConfig({ runtime: 'codex' } as Partial<GSDConfig>),
+        { model: 'gpt-5.3-codex' },
+      );
+      const opts = mockQueryCalls[0].options as { model?: string };
+      expect(opts.model).toBe('gpt-5.3-codex');
+    });
+  });
+});

package/sdk/src/session-runner.ts

@@ -0,0 +1,327 @@
+/**
+ * Session runner — orchestrates Agent SDK query() calls for plan execution.
+ *
+ * Takes a parsed plan, builds the executor prompt, configures query() options,
+ * processes the message stream, and extracts results into a typed PlanResult.
+ */
+
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import type { SDKMessage, SDKResultMessage, SDKResultSuccess, SDKResultError } from '@anthropic-ai/claude-agent-sdk';
+import type { ParsedPlan, PlanResult, SessionOptions, SessionUsage, GSDCostUpdateEvent, PhaseStepType } from './types.js';
+import { GSDEventType, PhaseType } from './types.js';
+import type { GSDConfig } from './config.js';
+import { buildExecutorPrompt, parseAgentTools, DEFAULT_ALLOWED_TOOLS } from './prompt-builder.js';
+import type { GSDEventStream, EventStreamContext } from './event-stream.js';
+import { getToolsForPhase } from './tool-scoping.js';
+import { detectRuntime } from './query/helpers.js';
+import { resolveRuntimeTierDefault } from './model-catalog.js';
+
+// ─── Model resolution ────────────────────────────────────────────────────────
+
+/**
+ * Resolve model identifier from options or config profile.
+ *
+ * Priority: explicit model option > config model_profile > default.
+ *
+ * Runtime-aware (#2832): the profile -> Claude-id map only applies when the
+ * project is targeting the Claude runtime. For Codex, Gemini, OpenCode, etc.,
+ * forcing a Claude model id (e.g. 'claude-sonnet-4-6') silently routes the
+ * autonomous run through the Claude path, which is wrong for those runtimes.
+ * In those cases — and whenever `resolve_model_ids: "omit"` is set — leave
+ * `model` unset so the runtime falls back to its configured default.
+ */
+function resolveModel(options?: SessionOptions, config?: GSDConfig): string | undefined {
+  if (options?.model) return options.model;
+
+  // Honor the explicit "don't resolve model ids" config knob (#2652, #2832).
+  // Mirrors `query/config-query.ts` resolve_model_ids === 'omit' branch.
+  if ((config as Record<string, unknown> | undefined)?.resolve_model_ids === 'omit') {
+    return undefined;
+  }
+
+  // Profile -> Claude id map. Applies only on the Claude runtime.
+  // Use `detectRuntime` so `GSD_RUNTIME` env precedence is honored — a Codex
+  // run with a Claude-shaped config must NOT be silently routed to Claude.
+  const runtime = detectRuntime({
+    runtime: (config as Record<string, unknown> | undefined)?.runtime,
+  });
+  if (runtime !== 'claude') {
+    // Non-Claude runtimes: never inject a Claude id from the profile map.
+    return undefined;
+  }
+
+  if (config?.model_profile) {
+    const profile = String(config.model_profile).toLowerCase();
+    if (profile === 'inherit') return undefined;
+    const tier = profile === 'quality' ? 'opus'
+      : (profile === 'budget' || profile === 'speed') ? 'haiku'
+      : (profile === 'balanced' || profile === 'adaptive') ? 'sonnet'
+      : null;
+    if (!tier) return config.model_profile;
+    return resolveRuntimeTierDefault('claude', tier)?.model;
+  }
+
+  return undefined; // Let SDK use its default
+}
+
+// ─── Session runner ──────────────────────────────────────────────────────────
+
+/**
+ * Run a plan execution session via the Agent SDK query() function.
+ *
+ * Builds the executor prompt from the parsed plan, configures query() with
+ * appropriate permissions, tool restrictions, and budget limits, then iterates
+ * the message stream to extract the result.
+ *
+ * @param plan - Parsed plan structure
+ * @param config - GSD project configuration
+ * @param options - Session overrides (maxTurns, budget, model, etc.)
+ * @param agentDef - Raw agent definition content (optional, for tool/role extraction)
+ * @returns Typed PlanResult with cost, duration, success/error status
+ */
+export async function runPlanSession(
+  plan: ParsedPlan,
+  config: GSDConfig,
+  options?: SessionOptions,
+  agentDef?: string,
+  eventStream?: GSDEventStream,
+  streamContext?: EventStreamContext,
+  phaseDir?: string,
+): Promise<PlanResult> {
+  // Build the executor prompt
+  const executorPrompt = buildExecutorPrompt(plan, { agentDef, phaseDir });
+
+  // Resolve allowed tools — from agent definition or defaults
+  const allowedTools = options?.allowedTools ??
+    (agentDef ? parseAgentTools(agentDef) : DEFAULT_ALLOWED_TOOLS);
+
+  // Resolve model
+  const model = resolveModel(options, config);
+
+  // Configure query options
+  const maxTurns = options?.maxTurns ?? 50;
+  const maxBudgetUsd = options?.maxBudgetUsd ?? 5.0;
+  const cwd = options?.cwd ?? process.cwd();
+
+  const queryStream = query({
+    prompt: `Execute this plan:\n\n${plan.objective || 'Execute the plan tasks below.'}`,
+    options: {
+      systemPrompt: {
+        type: 'preset',
+        preset: 'claude_code',
+        append: executorPrompt,
+      },
+      settingSources: ['project'],
+      allowedTools,
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
+      maxTurns,
+      maxBudgetUsd,
+      cwd,
+      ...(model ? { model } : {}),
+    },
+  });
+
+  return processQueryStream(queryStream, eventStream, streamContext);
+}
+
+// ─── Result extraction ───────────────────────────────────────────────────────
+
+function isResultMessage(msg: SDKMessage): msg is SDKResultMessage {
+  return msg.type === 'result';
+}
+
+function isSuccessResult(msg: SDKResultMessage): msg is SDKResultSuccess {
+  return msg.subtype === 'success';
+}
+
+function isErrorResult(msg: SDKResultMessage): msg is SDKResultError {
+  return msg.subtype !== 'success';
+}
+
+function emptyUsage(): SessionUsage {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+  };
+}
+
+function extractUsage(msg: SDKResultMessage): SessionUsage {
+  const u = msg.usage;
+  return {
+    inputTokens: u.input_tokens ?? 0,
+    outputTokens: u.output_tokens ?? 0,
+    cacheReadInputTokens: u.cache_read_input_tokens ?? 0,
+    cacheCreationInputTokens: u.cache_creation_input_tokens ?? 0,
+  };
+}
+
+function extractResult(msg: SDKResultMessage): PlanResult {
+  const base = {
+    sessionId: msg.session_id,
+    totalCostUsd: msg.total_cost_usd,
+    durationMs: msg.duration_ms,
+    usage: extractUsage(msg),
+    numTurns: msg.num_turns,
+  };
+
+  if (isSuccessResult(msg)) {
+    return {
+      ...base,
+      success: true,
+    };
+  }
+
+  // Error result
+  const errorMsg = msg as SDKResultError;
+  return {
+    ...base,
+    success: false,
+    error: {
+      subtype: errorMsg.subtype,
+      messages: errorMsg.errors ?? [],
+    },
+  };
+}
+
+// ─── Shared stream processing ────────────────────────────────────────────────
+
+/**
+ * Process a query() message stream, emit events, and extract the result.
+ * Shared between runPlanSession and runPhaseStepSession to avoid duplication.
+ */
+async function processQueryStream(
+  queryStream: AsyncIterable<SDKMessage>,
+  eventStream?: GSDEventStream,
+  streamContext?: EventStreamContext,
+): Promise<PlanResult> {
+  let resultMessage: SDKResultMessage | undefined;
+
+  try {
+    for await (const message of queryStream) {
+      if (eventStream) {
+        eventStream.mapAndEmit(message, streamContext ?? {});
+      }
+      if (isResultMessage(message)) {
+        resultMessage = message;
+      }
+    }
+  } catch (err) {
+    return {
+      success: false,
+      sessionId: '',
+      totalCostUsd: 0,
+      durationMs: 0,
+      usage: emptyUsage(),
+      numTurns: 0,
+      error: {
+        subtype: 'error_during_execution',
+        messages: [err instanceof Error ? err.message : String(err)],
+      },
+    };
+  }
+
+  if (!resultMessage) {
+    return {
+      success: false,
+      sessionId: '',
+      totalCostUsd: 0,
+      durationMs: 0,
+      usage: emptyUsage(),
+      numTurns: 0,
+      error: {
+        subtype: 'error_during_execution',
+        messages: ['No result message received from query stream'],
+      },
+    };
+  }
+
+  const result = extractResult(resultMessage);
+
+  if (eventStream) {
+    const cost = eventStream.getCost();
+    eventStream.emitEvent({
+      type: GSDEventType.CostUpdate,
+      timestamp: new Date().toISOString(),
+      sessionId: resultMessage.session_id,
+      phase: streamContext?.phase,
+      planName: streamContext?.planName,
+      sessionCostUsd: result.totalCostUsd,
+      cumulativeCostUsd: cost.cumulative,
+    } as GSDCostUpdateEvent);
+  }
+
+  return result;
+}
+
+// ─── Phase step session runner ───────────────────────────────────────────────
+
+/**
+ * Map PhaseStepType to PhaseType for tool scoping.
+ * PhaseStepType includes 'advance' which has no session-level equivalent.
+ */
+function stepTypeToPhaseType(step: PhaseStepType): PhaseType {
+  const mapping: Record<string, PhaseType> = {
+    discuss: PhaseType.Discuss,
+    research: PhaseType.Research,
+    plan: PhaseType.Plan,
+    plan_check: PhaseType.Verify,
+    execute: PhaseType.Execute,
+    verify: PhaseType.Verify,
+  };
+  return mapping[step] ?? PhaseType.Execute;
+}
+
+/**
+ * Run a phase step session via the Agent SDK query() function.
+ *
+ * Unlike runPlanSession which takes a ParsedPlan, this accepts a raw prompt
+ * string and a phase step type. The prompt becomes the system prompt append,
+ * and tools are scoped by phase type.
+ *
+ * @param prompt - Raw prompt string to append to the system prompt
+ * @param phaseStep - Phase step type (determines tool scoping)
+ * @param config - GSD project configuration
+ * @param options - Session overrides (maxTurns, budget, model, etc.)
+ * @param eventStream - Optional event stream for observability
+ * @param streamContext - Optional context for event tagging
+ * @returns Typed PlanResult with cost, duration, success/error status
+ */
+export async function runPhaseStepSession(
+  prompt: string,
+  phaseStep: PhaseStepType,
+  config: GSDConfig,
+  options?: SessionOptions,
+  eventStream?: GSDEventStream,
+  streamContext?: EventStreamContext,
+): Promise<PlanResult> {
+  const phaseType = stepTypeToPhaseType(phaseStep);
+  const allowedTools = options?.allowedTools ?? getToolsForPhase(phaseType);
+  const model = resolveModel(options, config);
+  const maxTurns = options?.maxTurns ?? 50;
+  const maxBudgetUsd = options?.maxBudgetUsd ?? 5.0;
+  const cwd = options?.cwd ?? process.cwd();
+
+  const queryStream = query({
+    prompt: `Execute this phase step: ${phaseStep}`,
+    options: {
+      systemPrompt: {
+        type: 'preset',
+        preset: 'claude_code',
+        append: prompt,
+      },
+      settingSources: ['project'],
+      allowedTools,
+      permissionMode: 'bypassPermissions',
+      allowDangerouslySkipPermissions: true,
+      maxTurns,
+      maxBudgetUsd,
+      cwd,
+      ...(model ? { model } : {}),
+    },
+  });
+
+  return processQueryStream(queryStream, eventStream, streamContext);
+}