@cluesmith/codev 3.0.0-rc.1 → 3.0.0-rc.11

package/dist/commands/consult/index.js

@@ -14,13 +14,19 @@ import chalk from 'chalk';
 import { query as claudeQuery } from '@anthropic-ai/claude-agent-sdk';
 import { Codex } from '@openai/codex-sdk';
 import { readCodevFile, findWorkspaceRoot } from '../../lib/skeleton.js';
+import { getResolver } from '../porch/artifacts.js';
 import { MetricsDB } from './metrics.js';
 import { extractUsage, extractReviewText } from './usage-extractor.js';
+import { executeForgeCommandSync } from '../../lib/forge.js';
 const MODEL_CONFIGS = {
     gemini: { cli: 'gemini', args: ['--model', 'gemini-3-pro-preview'], envVar: 'GEMINI_SYSTEM_MD' },
+    hermes: { cli: 'hermes', args: ['chat', '-q'], envVar: null },
 };
 // Models that use an Agent SDK instead of CLI subprocess
 const SDK_MODELS = ['claude', 'codex'];
+// Prevent E2BIG when passing very large prompts to CLI backends.
+// Large payloads are written to a temp file and referenced in the query.
+const CLI_PROMPT_INLINE_MAX_CHARS = 100_000;
 // Claude Agent SDK turn limit. Claude explores the codebase with Read/Glob/Grep
 // tools before producing its verdict, so it needs a generous turn budget.
 const CLAUDE_MAX_TURNS = 200;
@@ -129,46 +135,28 @@ function loadDotenv(workspaceRoot) {
     }
 }
 /**
- * Find a spec file by number. Returns null if not found.
- * Errors if multiple matches found.
+ * Find spec content by project ID using the artifact resolver.
+ * Returns a ContentRef with content and label, or null if not found.
  */
-function findSpec(workspaceRoot, number) {
-    const specsDir = path.join(workspaceRoot, 'codev', 'specs');
-    const unpadded = String(number);
-    const padded = unpadded.padStart(4, '0');
-    if (fs.existsSync(specsDir)) {
-        const files = fs.readdirSync(specsDir).filter(f => f.endsWith('.md'));
-        const matches = files.filter(f => f.startsWith(`${unpadded}-`) || f.startsWith(`${padded}-`));
-        if (matches.length > 1) {
-            const list = matches.map(f => `  - codev/specs/${f}`).join('\n');
-            throw new Error(`Multiple spec files match '${unpadded}' or '${padded}':\n${list}`);
-        }
-        if (matches.length === 1) {
-            return path.join(specsDir, matches[0]);
-        }
-    }
-    return null;
+function findSpecContent(workspaceRoot, id) {
+    const resolver = getResolver(workspaceRoot);
+    const content = resolver.getSpecContent(id, '');
+    if (!content)
+        return null;
+    const label = resolver.findSpecBaseName(id, '') ?? id;
+    return { content, label };
 }
 /**
- * Find a plan file by number. Returns null if not found.
- * Errors if multiple matches found.
+ * Find plan content by project ID using the artifact resolver.
+ * Returns a ContentRef with content and label, or null if not found.
  */
-function findPlan(workspaceRoot, number) {
-    const plansDir = path.join(workspaceRoot, 'codev', 'plans');
-    const unpadded = String(number);
-    const padded = unpadded.padStart(4, '0');
-    if (fs.existsSync(plansDir)) {
-        const files = fs.readdirSync(plansDir).filter(f => f.endsWith('.md'));
-        const matches = files.filter(f => f.startsWith(`${unpadded}-`) || f.startsWith(`${padded}-`));
-        if (matches.length > 1) {
-            const list = matches.map(f => `  - codev/plans/${f}`).join('\n');
-            throw new Error(`Multiple plan files match '${unpadded}' or '${padded}':\n${list}`);
-        }
-        if (matches.length === 1) {
-            return path.join(plansDir, matches[0]);
-        }
-    }
-    return null;
+function findPlanContent(workspaceRoot, id) {
+    const resolver = getResolver(workspaceRoot);
+    const content = resolver.getPlanContent(id, '');
+    if (!content)
+        return null;
+    const baseName = resolver.findSpecBaseName(id, '') ?? id;
+    return { content, label: baseName };
 }
 /**
  * Check if running in a builder worktree
@@ -309,11 +297,11 @@ export async function runCodexConsultation(queryText, role, workspaceRoot, outpu
     try {
         const codex = new Codex({
             config: {
-                experimental_instructions_file: tempFile,
+                model_instructions_file: tempFile,
             },
         });
         const thread = codex.startThread({
-            model: 'gpt-5.2-codex',
+            model: 'gpt-5.4',
             sandboxMode: 'read-only',
             modelReasoningEffort: 'medium',
             workingDirectory: workspaceRoot,
@@ -508,28 +496,72 @@ async function runConsultation(model, query, workspaceRoot, role, outputPath, me
     let tempFile = null;
     const env = {};
     let cmd;
+    // When true, the query is written to the child's stdin instead of argv.
+    // Used for gemini to avoid V8 heap exhaustion on large prompts (#680).
+    let stdinPayload = null;
     if (model === 'gemini') {
         // Gemini uses GEMINI_SYSTEM_MD env var for role
         tempFile = path.join(tmpdir(), `codev-role-${Date.now()}.md`);
         fs.writeFileSync(tempFile, role);
         env['GEMINI_SYSTEM_MD'] = tempFile;
+        // Bugfix #680: gemini-cli v0.37.x crashes on large PR diffs (>500KB) due to
+        // V8 old-space exhaustion in the spawned subprocess. Mitigations:
+        //   1. Bump heap via NODE_OPTIONS (survives gemini-cli's internal relaunch).
+        //   2. Pipe the prompt via stdin instead of argv — avoids ARG_MAX and keeps
+        //      V8 from holding the full prompt buffer twice.
+        env['NODE_OPTIONS'] = [process.env.NODE_OPTIONS ?? '', '--max-old-space-size=8192']
+            .join(' ')
+            .trim();
+        stdinPayload = query;
         // Use --output-format json to capture token usage/cost in structured output.
         // Never use --yolo — it allows Gemini to write files (#370).
-        cmd = [config.cli, '--output-format', 'json', ...config.args, query];
+        // No positional query arg: prompt arrives on stdin (triggers non-interactive mode).
+        cmd = [config.cli, '--output-format', 'json', ...config.args];
+    }
+    else if (model === 'hermes') {
+        // Hermes does not have a dedicated system prompt flag for single-shot mode.
+        // Include role context at the top of the prompt.
+        const hermesPrompt = `${role}\n\n---\n\n${query}`;
+        // Large inline CLI args can exceed OS ARG_MAX and fail with E2BIG.
+        // For very large prompts, write the full prompt to a temp file and pass
+        // an instruction that points Hermes at that file.
+        if (hermesPrompt.length > CLI_PROMPT_INLINE_MAX_CHARS) {
+            tempFile = path.join(tmpdir(), `codev-consult-prompt-${Date.now()}.md`);
+            fs.writeFileSync(tempFile, hermesPrompt);
+            const instruction = [
+                `Read the full consultation prompt from this file: ${tempFile}`,
+                'You have file access. Read files directly from disk to review code.',
+            ].join('\n\n');
+            cmd = [config.cli, ...config.args, instruction];
+        }
+        else {
+            cmd = [config.cli, ...config.args, hermesPrompt];
+        }
     }
     else {
         throw new Error(`Unknown model: ${model}`);
     }
-    // Execute with passthrough stdio
-    // Use 'ignore' for stdin to prevent blocking when spawned as subprocess
+    // Execute with passthrough stdio.
+    // Use 'ignore' for stdin when no payload — prevents blocking when spawned as subprocess.
+    // Use 'pipe' when we need to stream the prompt in (e.g. gemini, see #680).
     const fullEnv = { ...process.env, ...env };
     const startTime = Date.now();
+    const stdinMode = stdinPayload !== null ? 'pipe' : 'ignore';
     return new Promise((resolve, reject) => {
         const proc = spawn(cmd[0], cmd.slice(1), {
             cwd: workspaceRoot,
             env: fullEnv,
-            stdio: ['ignore', 'pipe', 'inherit'],
+            stdio: [stdinMode, 'pipe', 'inherit'],
         });
+        if (stdinPayload !== null && proc.stdin) {
+            proc.stdin.on('error', (err) => {
+                // EPIPE can happen if the child exits before reading all input — not fatal.
+                if (err.code !== 'EPIPE') {
+                    reject(err);
+                }
+            });
+            proc.stdin.end(stdinPayload, 'utf-8');
+        }
         const chunks = [];
         if (proc.stdout) {
             proc.stdout.on('data', (chunk) => {
@@ -609,17 +641,31 @@ function getDiffStat(workspaceRoot, ref) {
     return { stat, files };
 }
 /**
- * Fetch PR metadata (no diff — that's fetched separately)
+ * Fetch PR metadata via forge concept commands (no diff — that's fetched separately).
  */
-function fetchPRData(prNumber) {
-    console.error(`Fetching PR #${prNumber} data...`);
+function fetchPRData(prId) {
+    console.error(`Fetching PR #${prId} data...`);
     try {
-        const info = execSync(`gh pr view ${prNumber} --json title,body,state,author,baseRefName,headRefName,additions,deletions`, { encoding: 'utf-8' });
-        const nameOnly = execSync(`gh pr diff ${prNumber} --name-only`, { encoding: 'utf-8' });
+        const prView = executeForgeCommandSync('pr-view', {
+            CODEV_PR_NUMBER: prId,
+        });
+        const info = typeof prView === 'string' ? prView : JSON.stringify(prView);
+        const diffResult = executeForgeCommandSync('pr-diff', {
+            CODEV_PR_NUMBER: prId,
+            CODEV_DIFF_NAME_ONLY: '1',
+        }, { raw: true });
+        const nameOnly = typeof diffResult === 'string' ? diffResult : '';
         const changedFiles = nameOnly.trim().split('\n').filter(Boolean);
         let comments = '(No comments)';
         try {
-            comments = execSync(`gh pr view ${prNumber} --comments`, { encoding: 'utf-8' });
+            // Fetch PR comments via pr-view concept with CODEV_INCLUDE_COMMENTS flag
+            const commentsResult = executeForgeCommandSync('pr-view', {
+                CODEV_PR_NUMBER: prId,
+                CODEV_INCLUDE_COMMENTS: '1',
+            }, { raw: true });
+            if (commentsResult && typeof commentsResult === 'string' && commentsResult.trim()) {
+                comments = commentsResult;
+            }
         }
         catch {
             // No comments or error fetching
@@ -631,44 +677,53 @@ function fetchPRData(prNumber) {
     }
 }
 /**
- * Fetch the full PR diff via gh pr diff
+ * Fetch the full PR diff via the pr-diff forge concept command.
  */
-function fetchPRDiff(prNumber) {
+function fetchPRDiff(prId) {
     try {
-        return execSync(`gh pr diff ${prNumber}`, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+        const result = executeForgeCommandSync('pr-diff', {
+            CODEV_PR_NUMBER: prId,
+        }, { raw: true });
+        return typeof result === 'string' ? result : '';
     }
     catch (err) {
-        throw new Error(`Failed to fetch PR diff for #${prNumber}: ${err}`);
+        throw new Error(`Failed to fetch PR diff for #${prId}: ${err}`);
     }
 }
 /**
- * Build query for PR review.
- * Includes full PR diff + file list; model reads surrounding context from disk.
+ * Compose the PR review prompt text from already-fetched pieces.
+ *
+ * Split from the I/O wrapper so it can be tested without mocking the forge
+ * layer. Points the model at a temp-file path rather than inlining the diff:
+ * large (~800KB+) inlined diffs blow past the gemini-cli JSON path and bloat
+ * prompts for all models (#684).
  */
-function buildPRQuery(prNumber) {
-    const prData = fetchPRData(prNumber);
-    const diff = fetchPRDiff(prNumber);
-    const fileList = prData.changedFiles.map(f => `- ${f}`).join('\n');
-    return `Review Pull Request #${prNumber}
+function composePRQueryText(params) {
+    const { prId, info, changedFiles, comments, diffPath, diffBytes, diffLines } = params;
+    const fileList = changedFiles.map(f => `- ${f}`).join('\n');
+    const diffSizeKb = (diffBytes / 1024).toFixed(1);
+    return `Review Pull Request #${prId}
 
 ## PR Info
 \`\`\`json
-${prData.info}
+${info}
 \`\`\`
 
-## Changed Files
+## Changed Files (${changedFiles.length})
 ${fileList}
 
 ## PR Diff
-\`\`\`diff
-${diff}
-\`\`\`
+The full PR diff is **not inlined** in this prompt to keep the payload small. It has been written to this path on disk:
+
+**Diff file**: \`${diffPath}\`
+**Size**: ${diffSizeKb} KB (${diffBytes} bytes, ${diffLines} lines)
 
 ## How to Review
-Review the PR diff above for the changes. You also have **full filesystem access** — read files from disk for surrounding context beyond what the diff shows.
+1. **Read the diff file** from \`${diffPath}\` to see the exact changes (use the Read tool or \`cat\`).
+2. You have **full filesystem access** — read any project files from disk for surrounding context beyond what the diff shows.
 
 ## Comments
-${prData.comments}
+${comments}
 
 ---
 
@@ -690,25 +745,58 @@ CONFIDENCE: [HIGH | MEDIUM | LOW]
 
 KEY_ISSUES: [List of critical issues if any, or "None"]`;
 }
+/**
+ * Build query for PR review.
+ *
+ * Writes the full PR diff to a temp file and points the model at the path
+ * instead of inlining it. Inlining large diffs (~800KB+) caused gemini-cli's
+ * JSON output path to fail with "Unexpected end of JSON input" in 0.3s
+ * (#684); it also bloats prompts for Claude/Codex. This mirrors the pattern
+ * used by buildImplQuery.
+ *
+ * The temp file is left in place for the model to read during consultation.
+ * OS /tmp rotation handles cleanup.
+ */
+function buildPRQuery(prId) {
+    const prData = fetchPRData(prId);
+    const diff = fetchPRDiff(prId);
+    // Private-per-user dir to avoid world-readable /tmp diffs + symlink/clobber
+    // races: mkdtempSync creates a fresh dir owned by us; writeFileSync with
+    // flag 'wx' refuses to follow a symlink or overwrite an existing file.
+    const diffDir = fs.mkdtempSync(path.join(tmpdir(), 'codev-pr-'));
+    const diffPath = path.join(diffDir, `pr-${prId}.diff`);
+    fs.writeFileSync(diffPath, diff, { encoding: 'utf-8', mode: 0o600, flag: 'wx' });
+    const diffBytes = Buffer.byteLength(diff, 'utf-8');
+    const diffLines = diff ? diff.split('\n').length : 0;
+    return composePRQueryText({
+        prId,
+        info: prData.info,
+        changedFiles: prData.changedFiles,
+        comments: prData.comments,
+        diffPath,
+        diffBytes,
+        diffLines,
+    });
+}
 /**
  * Build query for spec review
  */
-function buildSpecQuery(specPath, planPath) {
-    let query = `Review Specification: ${path.basename(specPath)}
+function buildSpecQuery(spec, plan) {
+    let query = `Review Specification: ${spec.label}
+
+## Specification
+
+${spec.content}
 
-Please read and review this specification:
-- Spec file: ${specPath}
 `;
-    if (planPath) {
-        query += `- Plan file: ${planPath}\n`;
-    }
-    query += `
-## How to Review
-**Read the files listed above directly from disk.** You have full filesystem access.
-Do NOT rely on \`git diff\` or \`git log\` to review content — diffs may be truncated or miss uncommitted work.
-Open the spec file, read it in full, and evaluate it directly.
+    if (plan) {
+        query += `## Plan
 
-Please review:
+${plan.content}
+
+`;
+    }
+    query += `Please review:
 1. Clarity and completeness of requirements
 2. Technical feasibility
 3. Edge cases and error scenarios
@@ -731,7 +819,7 @@ KEY_ISSUES: [List of critical issues if any, or "None"]`;
  * Build query for implementation review.
  * Accepts spec/plan paths and optional diff reference override.
  */
-function buildImplQuery(workspaceRoot, specPath, planPath, planPhase, diffRef) {
+function buildImplQuery(workspaceRoot, spec, plan, planPhase, diffRef) {
     // Get compact diff summary
     let diffStat = '';
     let changedFiles = [];
@@ -748,15 +836,15 @@ function buildImplQuery(workspaceRoot, specPath, planPath, planPhase, diffRef) {
     if (planPhase) {
         query += ` — Phase: ${planPhase}`;
     }
-    query += `\n\n## Context Files\n`;
-    if (specPath) {
-        query += `- Spec: ${specPath}\n`;
+    query += '\n\n';
+    if (spec) {
+        query += `## Specification\n\n${spec.content}\n\n`;
     }
-    if (planPath) {
-        query += `- Plan: ${planPath}\n`;
+    if (plan) {
+        query += `## Plan\n\n${plan.content}\n\n`;
     }
     if (planPhase) {
-        query += `\n## REVIEW SCOPE — CURRENT PLAN PHASE ONLY\n`;
+        query += `## REVIEW SCOPE — CURRENT PLAN PHASE ONLY\n`;
         query += `You are reviewing **plan phase "${planPhase}" ONLY**.\n`;
         query += `Read the plan, find the section for "${planPhase}", and scope your review to ONLY the work described in that phase.\n\n`;
         query += `**DO NOT** request changes for work that belongs to other plan phases.\n`;
@@ -774,7 +862,7 @@ function buildImplQuery(workspaceRoot, specPath, planPath, planPhase, diffRef) {
         query += `Do NOT rely on git diffs to determine the current state of code — diffs miss uncommitted changes in worktrees.\n`;
     }
     else {
-        query += `\n## Instructions\n\nRead the spec and plan files above, then explore the filesystem to find and review the implementation changes.\n`;
+        query += `\n## Instructions\n\nExplore the filesystem to find and review the implementation changes.\n`;
     }
     query += `
 Please review:
@@ -798,22 +886,22 @@ KEY_ISSUES: [List of critical issues if any, or "None"]`;
 /**
  * Build query for plan review
  */
-function buildPlanQuery(planPath, specPath) {
-    let query = `Review Implementation Plan: ${path.basename(planPath)}
+function buildPlanQuery(plan, spec) {
+    let query = `Review Implementation Plan: ${plan.label}
+
+## Plan
+
+${plan.content}
 
-Please read and review this implementation plan:
-- Plan file: ${planPath}
 `;
-    if (specPath) {
-        query += `- Spec file: ${specPath} (for context)\n`;
-    }
-    query += `
-## How to Review
-**Read the files listed above directly from disk.** You have full filesystem access.
-Do NOT rely on \`git diff\` or \`git log\` to review content — diffs may be truncated or miss uncommitted work.
-Open the plan file (and spec if provided), read them in full, and evaluate the plan directly.
+    if (spec) {
+        query += `## Specification (for context)
 
-Please review:
+${spec.content}
+
+`;
+    }
+    query += `Please review:
 1. Alignment with specification requirements
 2. Implementation approach and architecture
 3. Task breakdown and ordering
@@ -836,7 +924,7 @@ KEY_ISSUES: [List of critical issues if any, or "None"]`;
  * Build query for phase-scoped review.
  * Uses git show HEAD for the phase's atomic commit diff.
  */
-function buildPhaseQuery(workspaceRoot, planPhase, specPath, planPath) {
+function buildPhaseQuery(workspaceRoot, planPhase, spec, plan) {
     let phaseDiff = '';
     try {
         phaseDiff = execSync('git show HEAD', { cwd: workspaceRoot, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
@@ -844,11 +932,11 @@ function buildPhaseQuery(workspaceRoot, planPhase, specPath, planPath) {
     catch {
         // If git show fails, reviewer explores filesystem
     }
-    let query = `Review Phase Implementation: "${planPhase}"\n\n## Context Files\n`;
-    if (specPath)
-        query += `- Spec: ${specPath}\n`;
-    if (planPath)
-        query += `- Plan: ${planPath}\n`;
+    let query = `Review Phase Implementation: "${planPhase}"\n\n`;
+    if (spec)
+        query += `## Specification\n\n${spec.content}\n\n`;
+    if (plan)
+        query += `## Plan\n\n${plan.content}\n\n`;
     query += `
 ## REVIEW SCOPE — CURRENT PLAN PHASE ONLY
 You are reviewing **plan phase "${planPhase}" ONLY**.
@@ -885,92 +973,94 @@ KEY_ISSUES: [List of critical issues if any, or "None"]`;
     return query;
 }
 /**
- * Find PR number for the current branch
+ * Find PR number for the current branch via pr-search forge concept.
  */
 function findPRForCurrentBranch(workspaceRoot) {
     const branchName = execSync('git branch --show-current', { cwd: workspaceRoot, encoding: 'utf-8' }).trim();
-    const prJson = execSync(`gh pr list --head "${branchName}" --json number --jq '.[0].number'`, { cwd: workspaceRoot, encoding: 'utf-8' }).trim();
-    if (!prJson) {
-        throw new Error(`No PR found for branch: ${branchName}`);
-    }
-    const prNumber = parseInt(prJson, 10);
-    if (isNaN(prNumber)) {
+    const result = executeForgeCommandSync('pr-search', {
+        CODEV_SEARCH_QUERY: `head:${branchName}`,
+    }, { cwd: workspaceRoot });
+    const prs = Array.isArray(result) ? result : [];
+    if (prs.length === 0 || !prs[0]?.number) {
         throw new Error(`No PR found for branch: ${branchName}`);
     }
-    return prNumber;
+    return String(prs[0].number);
 }
 /**
- * Find PR number for a given issue number (architect mode)
+ * Find PR number for a given issue number (architect mode) via pr-search forge concept.
  */
-function findPRForIssue(workspaceRoot, issueNumber) {
-    const prJson = execSync(`gh pr list --search "${issueNumber}" --json number,headRefName --jq '.[0]'`, { cwd: workspaceRoot, encoding: 'utf-8' }).trim();
-    if (!prJson || prJson === 'null') {
-        throw new Error(`No PR found for issue #${issueNumber}`);
-    }
-    return JSON.parse(prJson);
+function findPRForIssue(workspaceRoot, issueId) {
+    const result = executeForgeCommandSync('pr-search', {
+        CODEV_SEARCH_QUERY: issueId,
+    }, { cwd: workspaceRoot });
+    const prs = Array.isArray(result) ? result : [];
+    if (prs.length === 0 || !prs[0]?.number) {
+        throw new Error(`No PR found for issue #${issueId}`);
+    }
+    return prs[0];
 }
 /**
  * Resolve query for builder context (auto-detected from porch state)
  */
 function resolveBuilderQuery(workspaceRoot, type, options) {
     const projectState = getBuilderProjectState(workspaceRoot, options.projectId);
-    const projectNumber = parseInt(projectState.id, 10);
+    const projectId = projectState.id;
     switch (type) {
         case 'spec': {
-            const specPath = findSpec(workspaceRoot, projectNumber);
-            if (!specPath)
-                throw new Error(`Spec ${projectState.id} not found in codev/specs/`);
-            const planPath = findPlan(workspaceRoot, projectNumber);
-            console.error(`Spec: ${specPath}`);
-            if (planPath)
-                console.error(`Plan: ${planPath}`);
-            return buildSpecQuery(specPath, planPath);
+            const spec = findSpecContent(workspaceRoot, projectId);
+            if (!spec)
+                throw new Error(`Spec ${projectId} not found`);
+            const plan = findPlanContent(workspaceRoot, projectId);
+            console.error(`Spec: ${spec.label}`);
+            if (plan)
+                console.error(`Plan: ${plan.label}`);
+            return buildSpecQuery(spec, plan);
         }
         case 'plan': {
-            const planPath = findPlan(workspaceRoot, projectNumber);
-            if (!planPath)
-                throw new Error(`Plan ${projectState.id} not found in codev/plans/`);
-            const specPath = findSpec(workspaceRoot, projectNumber);
-            console.error(`Plan: ${planPath}`);
-            if (specPath)
-                console.error(`Spec: ${specPath}`);
-            return buildPlanQuery(planPath, specPath);
+            const plan = findPlanContent(workspaceRoot, projectId);
+            if (!plan)
+                throw new Error(`Plan ${projectId} not found`);
+            const spec = findSpecContent(workspaceRoot, projectId);
+            console.error(`Plan: ${plan.label}`);
+            if (spec)
+                console.error(`Spec: ${spec.label}`);
+            return buildPlanQuery(plan, spec);
         }
         case 'impl': {
-            const specPath = findSpec(workspaceRoot, projectNumber);
-            const planPath = findPlan(workspaceRoot, projectNumber);
-            console.error(`Project: ${projectState.id}`);
-            if (specPath)
-                console.error(`Spec: ${specPath}`);
-            if (planPath)
-                console.error(`Plan: ${planPath}`);
+            const spec = findSpecContent(workspaceRoot, projectId);
+            const plan = findPlanContent(workspaceRoot, projectId);
+            console.error(`Project: ${projectId}`);
+            if (spec)
+                console.error(`Spec: ${spec.label}`);
+            if (plan)
+                console.error(`Plan: ${plan.label}`);
             if (options.planPhase)
                 console.error(`Plan phase: ${options.planPhase}`);
-            return buildImplQuery(workspaceRoot, specPath, planPath, options.planPhase);
+            return buildImplQuery(workspaceRoot, spec, plan, options.planPhase);
         }
         case 'pr': {
-            const prNumber = findPRForCurrentBranch(workspaceRoot);
-            console.error(`PR: #${prNumber}`);
-            return buildPRQuery(prNumber);
+            const prId = findPRForCurrentBranch(workspaceRoot);
+            console.error(`PR: #${prId}`);
+            return buildPRQuery(prId);
         }
         case 'phase': {
             const currentPhase = options.planPhase ?? projectState.currentPlanPhase;
             if (!currentPhase) {
                 throw new Error('No current plan phase detected. Use --plan-phase to specify.');
             }
-            const specPath = findSpec(workspaceRoot, projectNumber);
-            const planPath = findPlan(workspaceRoot, projectNumber);
+            const spec = findSpecContent(workspaceRoot, projectId);
+            const plan = findPlanContent(workspaceRoot, projectId);
             console.error(`Phase: ${currentPhase}`);
-            if (specPath)
-                console.error(`Spec: ${specPath}`);
-            if (planPath)
-                console.error(`Plan: ${planPath}`);
-            return buildPhaseQuery(workspaceRoot, currentPhase, specPath, planPath);
+            if (spec)
+                console.error(`Spec: ${spec.label}`);
+            if (plan)
+                console.error(`Plan: ${plan.label}`);
+            return buildPhaseQuery(workspaceRoot, currentPhase, spec, plan);
         }
         case 'integration': {
-            const prNumber = findPRForCurrentBranch(workspaceRoot);
-            console.error(`PR: #${prNumber} (integration review)`);
-            return buildPRQuery(prNumber);
+            const prId = findPRForCurrentBranch(workspaceRoot);
+            console.error(`PR: #${prId} (integration review)`);
+            return buildPRQuery(prId);
         }
         default:
             throw new Error(`Unknown review type: ${type}\nValid types: spec, plan, impl, pr, phase, integration`);
@@ -987,33 +1077,30 @@ function resolveArchitectQuery(workspaceRoot, type, options) {
         throw new Error(`--issue is required from architect context for --type ${type}.\n` +
             `Example: consult -m gemini --protocol spir --type ${type} --issue 42`);
     }
-    const issueNumber = parseInt(options.issue, 10);
-    if (isNaN(issueNumber)) {
-        throw new Error(`Invalid issue number: ${options.issue}`);
-    }
+    const issueId = options.issue;
     switch (type) {
         case 'spec': {
-            const specPath = findSpec(workspaceRoot, issueNumber);
-            if (!specPath)
-                throw new Error(`Spec ${issueNumber} not found in codev/specs/`);
-            const planPath = findPlan(workspaceRoot, issueNumber);
-            console.error(`Spec: ${specPath}`);
-            if (planPath)
-                console.error(`Plan: ${planPath}`);
-            return buildSpecQuery(specPath, planPath);
+            const spec = findSpecContent(workspaceRoot, issueId);
+            if (!spec)
+                throw new Error(`Spec ${issueId} not found`);
+            const plan = findPlanContent(workspaceRoot, issueId);
+            console.error(`Spec: ${spec.label}`);
+            if (plan)
+                console.error(`Plan: ${plan.label}`);
+            return buildSpecQuery(spec, plan);
         }
         case 'plan': {
-            const planPath = findPlan(workspaceRoot, issueNumber);
-            if (!planPath)
-                throw new Error(`Plan ${issueNumber} not found in codev/plans/`);
-            const specPath = findSpec(workspaceRoot, issueNumber);
-            console.error(`Plan: ${planPath}`);
-            if (specPath)
-                console.error(`Spec: ${specPath}`);
-            return buildPlanQuery(planPath, specPath);
+            const plan = findPlanContent(workspaceRoot, issueId);
+            if (!plan)
+                throw new Error(`Plan ${issueId} not found`);
+            const spec = findSpecContent(workspaceRoot, issueId);
+            console.error(`Plan: ${plan.label}`);
+            if (spec)
+                console.error(`Spec: ${spec.label}`);
+            return buildPlanQuery(plan, spec);
         }
         case 'impl': {
-            const pr = findPRForIssue(workspaceRoot, issueNumber);
+            const pr = findPRForIssue(workspaceRoot, issueId);
             // Fetch the branch and diff from merge-base
             try {
                 execSync(`git fetch origin ${pr.headRefName}`, { cwd: workspaceRoot, stdio: 'pipe' });
@@ -1022,24 +1109,24 @@ function resolveArchitectQuery(workspaceRoot, type, options) {
                 // May already be fetched
             }
             const mergeBase = execSync(`git merge-base main origin/${pr.headRefName}`, { cwd: workspaceRoot, encoding: 'utf-8' }).trim();
-            const specPath = findSpec(workspaceRoot, issueNumber);
-            const planPath = findPlan(workspaceRoot, issueNumber);
-            console.error(`Project: ${issueNumber} (PR #${pr.number}, branch: ${pr.headRefName})`);
-            if (specPath)
-                console.error(`Spec: ${specPath}`);
-            if (planPath)
-                console.error(`Plan: ${planPath}`);
-            return buildImplQuery(workspaceRoot, specPath, planPath, options.planPhase, `${mergeBase}..origin/${pr.headRefName}`);
+            const spec = findSpecContent(workspaceRoot, issueId);
+            const plan = findPlanContent(workspaceRoot, issueId);
+            console.error(`Project: ${issueId} (PR #${pr.number}, branch: ${pr.headRefName})`);
+            if (spec)
+                console.error(`Spec: ${spec.label}`);
+            if (plan)
+                console.error(`Plan: ${plan.label}`);
+            return buildImplQuery(workspaceRoot, spec, plan, options.planPhase, `${mergeBase}..origin/${pr.headRefName}`);
         }
         case 'pr': {
-            const pr = findPRForIssue(workspaceRoot, issueNumber);
+            const pr = findPRForIssue(workspaceRoot, issueId);
             console.error(`PR: #${pr.number}`);
-            return buildPRQuery(pr.number);
+            return buildPRQuery(String(pr.number));
         }
         case 'integration': {
-            const pr = findPRForIssue(workspaceRoot, issueNumber);
+            const pr = findPRForIssue(workspaceRoot, issueId);
             console.error(`PR: #${pr.number} (integration review)`);
-            return buildPRQuery(pr.number);
+            return buildPRQuery(String(pr.number));
         }
         default:
             throw new Error(`Unknown review type: ${type}\nValid types: spec, plan, impl, pr, phase, integration`);
@@ -1144,7 +1231,7 @@ export async function consult(options) {
         }
     }
     // Add file access instruction for Gemini
-    if (model === 'gemini') {
+    if (model === 'gemini' || model === 'hermes') {
         query += '\n\nYou have file access. Read files directly from disk to review code.';
     }
     // Show the query/prompt being sent
@@ -1182,5 +1269,5 @@ export async function consult(options) {
     await runConsultation(model, query, workspaceRoot, role, outputPath, metricsCtx, isGeneralMode);
 }
 // Exported for testing
-export { getDiffStat as _getDiffStat, buildSpecQuery as _buildSpecQuery, buildPlanQuery as _buildPlanQuery, computePersistentOutputPath as _computePersistentOutputPath, };
+export { getDiffStat as _getDiffStat, buildSpecQuery as _buildSpecQuery, buildPlanQuery as _buildPlanQuery, buildPRQuery as _buildPRQuery, composePRQueryText as _composePRQueryText, computePersistentOutputPath as _computePersistentOutputPath, };
 //# sourceMappingURL=index.js.map