copilot-guardian 0.2.5

package/src/engine/run.ts

@@ -0,0 +1,154 @@
+import path from "node:path";
+import chalk from "chalk";
+
+import { analyzeRun } from "./analyze.js";
+import { generatePatchOptions } from "./patch_options.js";
+import { ensureDir, writeJson, writeText } from "./util.js";
+
+export type RunFlags = {
+  showReasoning?: boolean;
+  showOptions?: boolean;
+  strategy?: "conservative" | "balanced" | "aggressive";
+  outDir?: string;
+  maxLogChars?: number;
+  fast?: boolean;
+};
+
+type AbstainDecision = {
+  abstain: boolean;
+  classification: "NOT_PATCHABLE" | "PATCHABLE";
+  reason: string;
+  signals: string[];
+};
+
+function detectForcedAbstain(ctx: any): AbstainDecision {
+  const step = String(ctx?.step || "");
+  const summary = String(ctx?.logSummary || "");
+  const excerptTail = String(ctx?.logExcerpt || "").slice(-6000);
+  const haystack = `${step}\n${summary}\n${excerptTail}`.toLowerCase();
+  const strongSignals: string[] = [];
+  const weakSignals: string[] = [];
+
+  const checks: Array<{ label: string; pattern: RegExp; strength: "strong" | "weak" }> = [
+    { label: "auth_401_403", strength: "strong", pattern: /\b(401|403)\b|unauthorized|forbidden|bad credentials|authentication failed/ },
+    { label: "github_token_permission", strength: "strong", pattern: /resource not accessible by integration|insufficient permissions|github_token permission|token does not have permission/ },
+    { label: "rate_limit", strength: "strong", pattern: /rate limit exceeded|api rate limit|secondary rate limit/ },
+    { label: "runner_unavailable", strength: "weak", pattern: /runner offline|no runners? available|waiting for a runner to pick up this job/ },
+    { label: "service_unavailable", strength: "weak", pattern: /service unavailable|502 bad gateway|503 service unavailable|temporarily unavailable/ },
+    { label: "permission_denied_generic", strength: "weak", pattern: /\bpermission denied\b/ }
+  ];
+
+  for (const check of checks) {
+    if (!check.pattern.test(haystack)) continue;
+    if (check.strength === "strong") strongSignals.push(check.label);
+    else weakSignals.push(check.label);
+  }
+
+  const shouldAbstain = strongSignals.length >= 1 || weakSignals.length >= 2;
+  const signals = [...strongSignals, ...weakSignals];
+
+  if (shouldAbstain) {
+    return {
+      abstain: true,
+      classification: "NOT_PATCHABLE",
+      reason: "Failure appears to be auth/permission/infra related; forcing abstain for safety.",
+      signals
+    };
+  }
+
+  return {
+    abstain: false,
+    classification: "PATCHABLE",
+    reason: "",
+    signals: []
+  };
+}
+
+export async function runGuardian(repo: string, runId: number, flags: RunFlags) {
+  const outDir = flags.outDir || path.join(process.cwd(), ".copilot-guardian");
+  ensureDir(outDir);
+  
+  console.log(chalk.bold.cyan('\n=== Copilot Guardian Analysis ===\n'));
+  console.log(chalk.dim(`Repository: ${repo}`));
+  console.log(chalk.dim(`Run ID: ${runId}`));
+  console.log(chalk.dim(`Output: ${outDir}\n`));
+
+  const { analysisPath, analysis, ctx } = await analyzeRun(
+    repo,
+    runId,
+    outDir,
+    flags.maxLogChars,
+    {
+      fast: Boolean(flags.fast)
+    }
+  );
+
+  // Default: generate options only if requested (for speed)
+  let patchIndex: any | undefined;
+  if (flags.showOptions) {
+    const abstainDecision = detectForcedAbstain(ctx);
+    if (abstainDecision.abstain) {
+      const abstainReport = {
+        timestamp: new Date().toISOString(),
+        repo,
+        run_id: runId,
+        classification: abstainDecision.classification,
+        reason: abstainDecision.reason,
+        signals: abstainDecision.signals,
+        recommended_actions: [
+          "Escalate to human operator for auth/permissions/infra remediation.",
+          "Do not auto-apply patches for this failure class.",
+          "Re-run Guardian after infrastructure/auth issue is resolved."
+        ]
+      };
+      writeJson(path.join(outDir, "abstain.report.json"), abstainReport);
+      patchIndex = { timestamp: new Date().toISOString(), results: [], abstain: abstainReport };
+      console.log(chalk.yellow('\n[!] Forced ABSTAIN triggered.'));
+      console.log(chalk.dim(`    Classification: ${abstainReport.classification}`));
+      console.log(chalk.dim(`    Signals: ${abstainReport.signals.join(", ")}`));
+      console.log(chalk.dim(`    Saved: ${path.join(outDir, "abstain.report.json")}\n`));
+    } else {
+      const { index } = await generatePatchOptions(analysis, outDir, {
+        fast: Boolean(flags.fast)
+      });
+      patchIndex = index;
+      const allNoGo = index?.results?.length > 0 && index.results.every((r: any) => r.verdict === "NO_GO");
+      if (allNoGo) {
+        const currentMax = Number.isFinite(flags.maxLogChars) ? Number(flags.maxLogChars) : 12000;
+        const suggestedMax = Math.min(currentMax * 3, 120000);
+        console.log(chalk.yellow('\n[!] All strategies are NO_GO.'));
+        console.log(chalk.dim(`    Suggestion: re-run diagnosis with wider logs (--max-log-chars ${suggestedMax}).`));
+        console.log(chalk.dim(`    Example: copilot-guardian run --repo ${repo} --run-id ${runId} --show-options --max-log-chars ${suggestedMax}\n`));
+      }
+    }
+  }
+
+  // Save a small summary report
+  const report = {
+    timestamp: new Date().toISOString(),
+    repo,
+    runId,
+    analysisPath,
+    patchIndexPath: flags.showOptions ? path.join(outDir, "patch_options.json") : null,
+    redacted: true
+  };
+  writeJson(path.join(outDir, "guardian.report.json"), report);
+  
+  console.log(chalk.green.bold('\n=== Guardian Complete ==='));
+  console.log(chalk.dim(`All artifacts saved to: ${outDir}`));
+  console.log(chalk.dim('\nGenerated files:'));
+  console.log(chalk.dim('  - analysis.json (multi-hypothesis results)'));
+  console.log(chalk.dim('  - reasoning_trace.json (audit trail)'));
+  console.log(chalk.dim('  - copilot.analysis.raw.txt (full Copilot response)'));
+  if (flags.showOptions) {
+    if (patchIndex?.abstain) {
+      console.log(chalk.dim('  - abstain.report.json (forced abstain classification)'));
+    } else {
+      console.log(chalk.dim('  - fix.*.patch (3 patch strategies)'));
+      console.log(chalk.dim('  - patch_options.json (quality review results)'));
+    }
+  }
+  console.log("");
+
+  return { analysis, patchIndex, outDir, ctx };
+}

package/src/engine/util.ts

@@ -0,0 +1,195 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import Ajv2020Module from "ajv/dist/2020.js";
+import addFormatsModule from "ajv-formats";
+
+// ESM default export handling
+const Ajv2020 = (Ajv2020Module as any).default || Ajv2020Module;
+const addFormats = (addFormatsModule as any).default || addFormatsModule;
+
+function findPackageRoot(startDir: string): string | undefined {
+  let current = path.resolve(startDir);
+  while (true) {
+    const packageJson = path.join(current, "package.json");
+    const promptsDir = path.join(current, "prompts");
+    const schemasDir = path.join(current, "schemas");
+    if (fs.existsSync(packageJson) && fs.existsSync(promptsDir) && fs.existsSync(schemasDir)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return undefined;
+}
+
+function resolvePackageRoot(): string {
+  const candidates: string[] = [];
+  if (typeof __dirname !== "undefined") candidates.push(__dirname);
+  if (typeof process.argv?.[1] === "string" && process.argv[1].trim()) {
+    candidates.push(path.dirname(path.resolve(process.argv[1])));
+  }
+  candidates.push(process.cwd());
+
+  for (const candidate of candidates) {
+    const resolved = findPackageRoot(candidate);
+    if (resolved) return resolved;
+  }
+  return process.cwd();
+}
+
+export const PACKAGE_ROOT = resolvePackageRoot();
+
+export type ExecOptions = {
+  cwd?: string;
+  input?: string;
+  env?: NodeJS.ProcessEnv;
+  stdio?: "pipe" | "inherit";
+};
+
+export function ensureDir(dir: string): void {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+export function loadText(p: string): string {
+  return fs.readFileSync(p, "utf8");
+}
+
+export function writeText(p: string, content: string): void {
+  ensureDir(path.dirname(p));
+  fs.writeFileSync(p, content, "utf8");
+}
+
+export function writeJson(p: string, obj: unknown): void {
+  writeText(p, JSON.stringify(obj, null, 2));
+}
+
+export function redactSecrets(text: string): string {
+  const patterns: RegExp[] = [
+    // GitHub tokens
+    /ghp_[a-zA-Z0-9]{36}/g,
+    /gho_[a-zA-Z0-9]{36}/g,
+    /github_pat_[a-zA-Z0-9_]{82}/g,
+    /ghs_[a-zA-Z0-9]{36}/g,
+    // Bearer tokens
+    /Bearer\s+[A-Za-z0-9\-._~+/]+=*/g,
+    // OpenAI keys
+    /sk-[a-zA-Z0-9]{48}/g,
+    // Generic secrets (key=value pattern)
+    /(token|password|secret|api_key|apikey|auth)\s*[:=]\s*['"]?[^\s'"]+['"]?/gi,
+    // AWS keys
+    /AKIA[0-9A-Z]{16}/g,
+    // Private keys
+    /-----BEGIN\s+(RSA|DSA|EC|OPENSSH)?\s*PRIVATE\s+KEY-----/g,
+  ];
+  // NOTE: Removed over-aggressive 40+ char alphanumeric pattern (S5 fix)
+  // It was redacting git SHAs, npm hashes, and other diagnostic data
+
+  let redacted = text;
+  for (const pattern of patterns) {
+    redacted = redacted.replace(pattern, "***REDACTED***");
+  }
+  return redacted;
+}
+
+export function findResidualSecrets(text: string): string[] {
+  const checks: Array<{ label: string; pattern: RegExp }> = [
+    { label: "github_token_classic", pattern: /gh[pousr]_[A-Za-z0-9]{20,}/g },
+    { label: "github_token_fine_grained", pattern: /github_pat_[A-Za-z0-9_]{30,}/g },
+    { label: "openai_key", pattern: /\bsk-[A-Za-z0-9]{20,}\b/g },
+    { label: "bearer_token", pattern: /Bearer\s+[A-Za-z0-9\-._~+/=]{16,}/g },
+    { label: "aws_access_key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+    { label: "private_key", pattern: /-----BEGIN\s+(?:RSA|DSA|EC|OPENSSH)?\s*PRIVATE\s+KEY-----/g },
+    { label: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g }
+  ];
+
+  const found = new Set<string>();
+  for (const check of checks) {
+    if (check.pattern.test(text)) {
+      found.add(check.label);
+    }
+  }
+  return Array.from(found);
+}
+
+export function extractJsonObject(text: string): string {
+  // Try to find JSON in various formats:
+  // 1. Pure JSON (starts with {)
+  // 2. JSON in markdown code block (```json ... ```)
+  // 3. JSON after prose text
+  
+  // First, try to extract from markdown code block
+  const codeBlockMatch = text.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  
+  // S4 FIX: Use non-greedy matching with balanced brace counting
+  // Find first { and match to its balanced closing }
+  const startIdx = text.indexOf('{');
+  if (startIdx === -1) {
+    // No JSON found - provide helpful error
+    const preview = text.substring(0, 200).replace(/\n/g, ' ');
+    throw new Error(
+      `No JSON object found in Copilot response.\n` +
+      `Response preview: "${preview}..."\n` +
+      `Hint: Copilot may have returned prose instead of JSON. Check copilot.*.raw.txt file.`
+    );
+  }
+  
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  
+  for (let i = startIdx; i < text.length; i++) {
+    const char = text[i];
+    
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    
+    if (char === '\\' && inString) {
+      escape = true;
+      continue;
+    }
+    
+    if (char === '"' && !escape) {
+      inString = !inString;
+      continue;
+    }
+    
+    if (!inString) {
+      if (char === '{') depth++;
+      else if (char === '}') {
+        depth--;
+        if (depth === 0) {
+          return text.slice(startIdx, i + 1);
+        }
+      }
+    }
+  }
+  
+  // Fallback: return from first { to end (may be truncated JSON)
+  throw new Error("Unbalanced JSON object in Copilot response - missing closing brace");
+}
+
+export function validateJson(data: unknown, schemaPath: string): void {
+  const ajv = new Ajv2020({ allErrors: true, strict: false });
+  addFormats(ajv);
+  const schema = JSON.parse(loadText(schemaPath));
+  const validate = ajv.compile(schema);
+  const ok = validate(data);
+  if (!ok) {
+    const errors = (validate.errors || [])
+      .map((e: { instancePath?: string; message?: string }) => `${e.instancePath || "(root)"}: ${e.message}`)
+      .join("\n");
+    throw new Error(`Schema validation failed (${schemaPath}):\n${errors}`);
+  }
+}
+
+export function clampText(s: string, maxChars: number): string {
+  if (s.length <= maxChars) return s;
+  return s.slice(0, maxChars) + "\n... [truncated]";
+}

package/src/ui/dashboard.ts

@@ -0,0 +1,90 @@
+import chalk from "chalk";
+
+// ASCII-safe block characters for cross-platform compatibility
+const BLOCK_FULL = '#';
+const BLOCK_LIGHT = '-';
+
+function riskRank(level: string): number {
+  if (level === "low") return 0;
+  if (level === "medium") return 1;
+  return 2;
+}
+
+function bar(p: number, width = 10): string {
+  const filled = Math.max(0, Math.min(width, Math.round(p * width)));
+  return BLOCK_FULL.repeat(filled) + BLOCK_LIGHT.repeat(width - filled);
+}
+
+export function renderHeader(repo: string, runId: number): void {
+  console.log("\n" + chalk.bold.bgCyan.black("  COPILOT-GUARDIAN  ") + "\n");
+  console.log(`${chalk.bold("Repo:")} ${repo}`);
+  console.log(`${chalk.bold("Run:")}  ${runId}`);
+}
+
+export function renderSummary(analysis: any): void {
+  console.log("\n" + chalk.bold.bgRed(" [X] FAILURE DIAGNOSIS ") + "\n");
+  console.log(`${chalk.bold("Root cause:")} ${analysis.diagnosis.root_cause}`);
+  console.log(`${chalk.bold("Selected:")}  ${analysis.diagnosis.selected_hypothesis_id} (${analysis.diagnosis.confidence_score})`);
+  console.log(`${chalk.bold("Intent:")}    ${analysis.patch_plan.intent}`);
+}
+
+export function renderHypotheses(hypotheses: any[]): void {
+  console.log("\n" + chalk.bold.bgMagenta.white("  MULTI-HYPOTHESIS REASONING  ") + "\n");
+
+  for (const h of hypotheses) {
+    const pct = Math.round((h.confidence ?? 0) * 100);
+    const b = bar(h.confidence ?? 0);
+
+    console.log(`${chalk.bold.cyan(h.id)} ${chalk.bold.white(h.title)}`);
+    console.log(`  Confidence: ${chalk.cyan(b)} ${chalk.cyan.bold(pct + "%")}`);
+    console.log(`  Evidence: ${chalk.dim((h.evidence?.[0] || "").slice(0, 140))}`);
+    if (h.next_check) {
+      console.log(`  Next check: ${chalk.yellow((h.next_check || "").slice(0, 140))}`);
+    }
+    console.log("");
+  }
+  
+  // Summary line
+  const selected = hypotheses.find(h => h.confidence === Math.max(...hypotheses.map(x => x.confidence ?? 0)));
+  if (selected) {
+    console.log(chalk.green.bold(`[SELECTED] ${selected.id}: ${selected.title}`));
+    console.log(chalk.dim(`Confidence: ${Math.round((selected.confidence ?? 0) * 100)}% - Highest among all hypotheses\n`));
+  }
+}
+
+export function renderPatchSpectrum(index: any): void {
+  console.log("\n" + chalk.bold.bgYellow.black("  PATCH SPECTRUM  ") + "\n");
+
+  for (const r of index.results) {
+    const badge = r.verdict === "GO" ? chalk.bgGreen.black(" GO ") : chalk.bgRed.white(" NO-GO ");
+
+    const risk = r.risk_level === "low" ? chalk.green("low") : r.risk_level === "medium" ? chalk.yellow("medium") : chalk.red("high");
+
+    const slopIndicator = r.slop_score > 0.5 ? chalk.red(` [SLOP: ${Math.round(r.slop_score * 100)}%]`) : "";
+
+    console.log(`${chalk.bold(String(r.label).padEnd(15))} ${badge}  risk=${risk}${slopIndicator}`);
+    console.log(`  patch:   ${chalk.dim(r.patchPath)}`);
+    if (r.files && r.files.length > 0) {
+      console.log(`  files:   ${chalk.dim(r.files.join(', '))}`);
+    }
+    if (r.summary) console.log(`  note:    ${chalk.dim(String(r.summary).slice(0, 160))}`);
+    console.log("");
+  }
+  
+  // Summary recommendation
+  const goStrategies = index.results.filter((r: any) => r.verdict === 'GO');
+  if (goStrategies.length > 0) {
+    const sorted = [...goStrategies].sort((a: any, b: any) => {
+      const riskDelta = riskRank(String(a?.risk_level)) - riskRank(String(b?.risk_level));
+      if (riskDelta !== 0) return riskDelta;
+      const slopA = Number.isFinite(Number(a?.slop_score)) ? Number(a.slop_score) : 1;
+      const slopB = Number.isFinite(Number(b?.slop_score)) ? Number(b.slop_score) : 1;
+      return slopA - slopB;
+    });
+    const recommended = sorted[0];
+    console.log(chalk.green.bold(`[RECOMMENDED] ${recommended.label}`));
+    console.log(chalk.dim(`Reason: Lowest risk and lowest slop among GO strategies\n`));
+  } else {
+    console.log(chalk.yellow.bold('[!] No GO strategies available - all flagged for slop or high risk\n'));
+  }
+}

package/test-sdk.mjs

@@ -0,0 +1,51 @@
+// Test script for Copilot SDK integration
+import { CopilotClient } from '@github/copilot-sdk';
+
+async function testSdk() {
+  console.log('[*] Testing Copilot SDK integration...\n');
+  
+  try {
+    console.log('[>] Creating CopilotClient...');
+    const client = new CopilotClient({
+      autoStart: true,
+      useLoggedInUser: true,
+    });
+    
+    console.log('[>] Starting client...');
+    await client.start();
+    console.log('[+] Client started successfully!\n');
+    
+    console.log('[>] Creating session with gpt-4o...');
+    const session = await client.createSession({
+      model: 'gpt-4o',
+    });
+    console.log('[+] Session created: ' + session.sessionId + '\n');
+    
+    console.log('[>] Sending test prompt...');
+    const testPrompt = 'Respond with exactly: "SDK TEST SUCCESSFUL"';
+    
+    const response = await session.sendAndWait({ prompt: testPrompt }, 30000);
+    
+    console.log('\n[+] Response received:');
+    console.log('---');
+    console.log(response?.data?.content || '(no content)');
+    console.log('---\n');
+    
+    console.log('[>] Cleaning up session...');
+    await session.destroy();
+    
+    console.log('[>] Stopping client...');
+    await client.stop();
+    
+    console.log('\n[*] SDK TEST COMPLETE - ALL SYSTEMS OPERATIONAL');
+    console.log('[*] copilot-guardian is ready to use Copilot SDK!');
+    
+  } catch (error) {
+    console.error('\n[-] SDK TEST FAILED:');
+    console.error(error.message);
+    console.error('\nFull error:', error);
+    process.exit(1);
+  }
+}
+
+testSdk();

package/tests/auto_heal_branch_safety.test.ts

@@ -0,0 +1,76 @@
+import {
+  ensureAutoHealBranch,
+  rerunLatestRunForCommit
+} from '../src/engine/auto-apply';
+import { execAsync } from '../src/engine/async-exec';
+
+jest.mock('../src/engine/async-exec', () => ({
+  execAsync: jest.fn()
+}));
+
+const mockedExecAsync = execAsync as jest.MockedFunction<typeof execAsync>;
+
+describe('auto-heal branch safety helpers', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('creates safe branch before patching flow when direct push is disabled', async () => {
+    mockedExecAsync
+      .mockResolvedValueOnce('main\n') // rev-parse
+      .mockResolvedValueOnce(''); // checkout -b
+
+    const ctx = await ensureAutoHealBranch(999, {
+      directPush: false,
+      baseBranch: 'main',
+      suffix: '12345678'
+    });
+
+    expect(mockedExecAsync).toHaveBeenNthCalledWith(1, 'git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+    expect(mockedExecAsync).toHaveBeenNthCalledWith(2, 'git', ['checkout', '-b', 'guardian/run-999-12345678']);
+    expect(ctx.createdSafeBranch).toBe(true);
+    expect(ctx.pushBranch).toBe('guardian/run-999-12345678');
+    expect(ctx.baseBranch).toBe('main');
+  });
+
+  test('does not create safe branch when direct push is enabled', async () => {
+    mockedExecAsync.mockResolvedValueOnce('main\n');
+
+    const ctx = await ensureAutoHealBranch(1000, {
+      directPush: true,
+      baseBranch: 'main'
+    });
+
+    expect(mockedExecAsync).toHaveBeenCalledTimes(1);
+    expect(ctx.createdSafeBranch).toBe(false);
+    expect(ctx.pushBranch).toBe('main');
+  });
+
+  test('reruns latest run for commit when available', async () => {
+    mockedExecAsync
+      .mockResolvedValueOnce(JSON.stringify([{ databaseId: 321, status: 'completed', conclusion: 'failure' }]))
+      .mockResolvedValueOnce('');
+
+    const runId = await rerunLatestRunForCommit('owner/repo', 'abc123');
+    expect(runId).toBe(321);
+    expect(mockedExecAsync).toHaveBeenNthCalledWith(1, 'gh', [
+      'run',
+      'list',
+      '--repo',
+      'owner/repo',
+      '--commit',
+      'abc123',
+      '--limit',
+      '1',
+      '--json',
+      'databaseId,status,conclusion'
+    ]);
+    expect(mockedExecAsync).toHaveBeenNthCalledWith(2, 'gh', [
+      'run',
+      'rerun',
+      '321',
+      '--repo',
+      'owner/repo'
+    ]);
+  });
+});

package/tests/github_redaction_failclosed.test.ts

@@ -0,0 +1,24 @@
+import { fetchRunContext } from '../src/engine/github';
+import { ghAsync } from '../src/engine/async-exec';
+
+jest.mock('../src/engine/async-exec', () => ({
+  ghAsync: jest.fn()
+}));
+
+const mockedGhAsync = ghAsync as jest.MockedFunction<typeof ghAsync>;
+
+describe('fetchRunContext redaction fail-closed', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('aborts when residual secret patterns remain after redaction', async () => {
+    const jwtLike = 'eyJabcdefgh12.eyJijklmnop34.eyJqrstuvwx56';
+    mockedGhAsync.mockResolvedValue(`Build log line with suspicious token ${jwtLike}`);
+
+    await expect(fetchRunContext('owner/repo', 1001, 12000)).rejects.toThrow(
+      /Redaction fail-closed/
+    );
+    expect(mockedGhAsync).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/mocks/copilot-sdk.mock.ts

@@ -0,0 +1,15 @@
+type SessionResponse = {
+  content?: string;
+};
+
+type Session = {
+  sendAndWait: (input: { prompt: string; mode: string }, timeoutMs?: number) => Promise<SessionResponse>;
+};
+
+export class CopilotClient {
+  async startSession(): Promise<Session> {
+    return {
+      sendAndWait: async () => ({ content: '' })
+    };
+  }
+}