scripts/modules/config-manager.js (1)

717-731: Add early return in getMcpApiKeyStatus for providers without API keys (includes gemini-cli).

Guidelines require an immediate-true check here, mirroring isApiKeySet. Without it, gemini-cli reports false.

Apply this diff:

 function getMcpApiKeyStatus(providerName, projectRoot = null) {
+	// Providers that do not require API keys (short-circuit true)
+	const providerKey = providerName?.toLowerCase();
+	if (
+		providerKey === 'gemini-cli' ||
+		providerKey === 'ollama' ||
+		providerKey === 'claude-code' ||
+		providerKey === 'bedrock' ||
+		providerKey === 'mcp'
+	) {
+		return true;
+	}
 	const rootDir = projectRoot || findProjectRoot(); // Use existing root finding

src/prompts/parse-prd.json (2)

44-49: Rename parameter to hasCodebaseAnalysis for consistency across prompts.

Aligns prompt API with code changes and other templates.

Apply this diff:

-		"isClaudeCode": {
+		"hasCodebaseAnalysis": {
 			"type": "boolean",
 			"required": false,
 			"default": false,
-			"description": "Whether codebase analysis is available (Claude Code or Gemini CLI)"
+			"description": "Whether codebase analysis is available (Claude Code or Gemini CLI)"
 		},

---

58-61: Update gating in user prompt to use hasCodebaseAnalysis.

Ensures the codebase analysis block renders when Gemini CLI/Claude Code is active.

Apply this diff:

-			"user": "{{#if isClaudeCode}}## IMPORTANT: Codebase Analysis Required
+			"user": "{{#if hasCodebaseAnalysis}}## IMPORTANT: Codebase Analysis Required

scripts/modules/task-manager/parse-prd/parse-prd-helpers.js (2)

15-16: Import hasCodebaseAnalysis from config-manager.

You’re calling a method on config; use the exported getter to avoid coupling and to pass research/root explicitly.

Apply this diff:

-import { getDefaultPriority } from '../../config-manager.js';
+import { getDefaultPriority, hasCodebaseAnalysis } from '../../config-manager.js';

---

238-247: Pass research/root and rename payload key to hasCodebaseAnalysis.

Using default args may mis-detect provider when research role is active; also align key with prompt rename.

Apply this diff:

 	return promptManager.loadPrompt('parse-prd', {
 		research: config.research,
 		numTasks: config.numTasks,
 		nextId,
 		prdContent,
 		prdPath: config.prdPath,
 		defaultTaskPriority,
-		isClaudeCode: config.hasCodebaseAnalysis(),
+		hasCodebaseAnalysis: hasCodebaseAnalysis(!!config.research, config.projectRoot),
 		projectRoot: config.projectRoot || ''
 	});

scripts/modules/task-manager/update-tasks.js (1)

433-441: Remove all remaining isClaudeCode references and related conditional logic

• Delete “isClaudeCode” schema entries and conditionals in JSON prompts:
  • src/prompts/update-tasks.json (lines 47–49)
  • src/prompts/parse-prd.json (lines 44–46)
  • src/prompts/update-task.json (lines 47–49)
  • src/prompts/expand-task.json (lines 55–57)
  • src/prompts/analyze-complexity.json (lines 34–36)
• Remove code usages of isClaudeCode in analyze-task-complexity.js (lines 421–426) and deprecate the isClaudeCode helper in config-manager.js
• Ensure prompt templates no longer include “## IMPORTANT: Codebase Analysis Required” blocks conditioned on isClaudeCode

scripts/modules/task-manager/update-task-by-id.js (1)

306-316: Move API-key-driven fallback out of core logic.
Per guidelines, avoid API key resolution and fallback logic here; delegate to ai-services-unified. This prevents drift and keeps policy centralized.

Apply:

-    if (useResearch && !isApiKeySet('perplexity', session)) {
-      report(
-        'warn',
-        'Perplexity research requested but API key not set. Falling back.'
-      );
-      if (outputFormat === 'text')
-        console.log(
-          chalk.yellow('Perplexity AI not available. Falling back to main AI.')
-        );
-      useResearch = false;
-    }
+    // Let ai-services-unified decide availability/fallback based on session/env.

scripts/modules/task-manager/add-task.js (1)

445-456: Consider switching to generateTextService + manual JSON parsing for robustness.
Guidelines note reliability issues with generateObjectService for some providers/schemas.

Minimal sketch:

- aiServiceResponse = await generateObjectService({
-   role: serviceRole,
-   session, projectRoot,
-   schema: AiTaskDataSchema,
-   objectName: 'newTaskData',
-   systemPrompt, prompt: userPrompt,
-   commandName: commandName || 'add-task',
-   outputType: outputType || (isMCP ? 'mcp' : 'cli')
- });
- const main = aiServiceResponse.mainResult;
- taskData = main.object ?? main;
+ aiServiceResponse = await generateTextService({
+   role: serviceRole,
+   session, projectRoot,
+   systemPrompt, prompt: userPrompt,
+   commandName: commandName || 'add-task',
+   outputType: outputType || (isMCP ? 'mcp' : 'cli')
+ });
+ const parsed = AiTaskDataSchema.safeParse(JSON.parse(aiServiceResponse.mainResult));
+ if (!parsed.success) throw new Error(parsed.error.message);
+ taskData = parsed.data;

scripts/modules/task-manager/expand-task.js (1)

461-471: Remove unused combinedAdditionalContext block.

It’s computed but never used. Drop to reduce noise.

-    // Combine all context sources into a single additionalContext parameter
-    let combinedAdditionalContext = '';
-    if (additionalContext || complexityReasoningContext) {
-      combinedAdditionalContext =
-        `\n\n${additionalContext}${complexityReasoningContext}`.trim();
-    }
-    if (gatheredContext) {
-      combinedAdditionalContext =
-        `${combinedAdditionalContext}\n\n# Project Context\n\n${gatheredContext}`.trim();
-    }

src/prompts/analyze-complexity.json (1)

34-38: Fix parameter description to reflect both providers.

Update wording to match repo-wide rename and capability.

-        "hasCodebaseAnalysis": {
-            "type": "boolean",
-            "default": false,
-            "description": "Whether Claude Code is being used as the provider"
-        },
+        "hasCodebaseAnalysis": {
+            "type": "boolean",
+            "default": false,
+            "description": "Whether codebase analysis is available (Claude Code or Gemini CLI)"
+        },

scripts/modules/config-manager.js (1)

719-801: Add 'gemini-cli' to MCP API key status fast-path.

Providers not requiring keys should return true here as well; otherwise Gemini CLI may be reported as missing credentials.

 		switch (providerName) {
 			case 'anthropic':
 				apiKeyToCheck = mcpEnv.ANTHROPIC_API_KEY;
 				placeholderValue = 'YOUR_ANTHROPIC_API_KEY_HERE';
 				break;
+			case 'gemini-cli':
+				return true; // No key needed
 			case 'openai':
 				apiKeyToCheck = mcpEnv.OPENAI_API_KEY;
 				placeholderValue = 'YOUR_OPENAI_API_KEY_HERE'; // Assuming placeholder matches OPENAI
 				break;

tests/unit/scripts/modules/task-manager/add-task.test.js (2)

100-105: Keep mock signature consistent with implementation

Accept args to mirror hasCodebaseAnalysis(useResearch, projectRoot).

-    hasCodebaseAnalysis: jest.fn(() => false)
+    hasCodebaseAnalysis: jest.fn((useResearch, projectRoot) => false)

---

237-287: Add a branch test with hasCodebaseAnalysis = true

To cover Gemini/Claude-codebase path, toggle the mock to true and assert the context-aware behavior (e.g., contextGatherer usage, prompt enrichment).

I can draft a focused test that sets hasCodebaseAnalysis.mockReturnValueOnce(true) and verifies the additional context flow. Want me to add it?

tests/unit/parse-prd.test.js (2)

270-286: Prefer mock-fs over real filesystem writes

These tests touch the actual temp FS. Use mock-fs for isolation/speed and to align with repo guidelines.

I can replace the tempDir setup with mock-fs and ensure proper restore in afterEach—say the word.

Also applies to: 295-301

---

324-371: Add coverage for codebase-analysis path

Include one test run with hasCodebaseAnalysis.mockReturnValueOnce(true) to validate projectRoot propagation and any codebase-context branches in parsePRD.

Happy to supply the exact test snippet.

tests/unit/scripts/modules/task-manager/parse-prd.test.js (1)

177-193: Add coverage for hasCodebaseAnalysis=true and prompt propagation.

Great that the mock exists. Add a test asserting loadPrompt receives { hasCodebaseAnalysis: true, projectRoot } when the capability is enabled.

+test('passes hasCodebaseAnalysis true and projectRoot to prompt payload', async () => {
+  const { getPromptManager } = await import('../../../../../scripts/modules/prompt-manager.js');
+  const mockLoadPrompt = jest.fn().mockResolvedValue({ systemPrompt: 'x', userPrompt: 'y' });
+  getPromptManager.mockReturnValue({ loadPrompt: mockLoadPrompt });
+  const { hasCodebaseAnalysis } = await import('../../../../../scripts/modules/config-manager.js');
+  hasCodebaseAnalysis.mockReturnValue(true);
+  await parsePRD('path/to/prd.txt', 'tasks/tasks.json', 3, {
+    tag: 'master',
+    projectRoot: '/repo',
+    mcpLog: { info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn(), success: jest.fn() }
+  });
+  expect(mockLoadPrompt).toHaveBeenCalledWith(
+    'parse-prd',
+    expect.objectContaining({ hasCodebaseAnalysis: true, projectRoot: '/repo' })
+  );
+});

tests/unit/scripts/modules/task-manager/expand-task.test.js (1)

121-131: Also assert prompt receives hasCodebaseAnalysis (true and false).

You mock the capability; add an assertion that expand-task passes it through to prompt params.

+test('propagates hasCodebaseAnalysis to prompt params', async () => {
+  const { getPromptManager } = await import('../../../../../scripts/modules/prompt-manager.js');
+  const mockLoadPrompt = jest.fn().mockResolvedValue({ systemPrompt: 's', userPrompt: 'u' });
+  getPromptManager.mockReturnValue({ loadPrompt: mockLoadPrompt });
+  const { hasCodebaseAnalysis } = await import('../../../../../scripts/modules/config-manager.js');
+  hasCodebaseAnalysis.mockReturnValue(true);
+  await expandTask('tasks/tasks.json', '2', 3, false, '', { projectRoot: '/mock/project/root' }, false);
+  expect(mockLoadPrompt).toHaveBeenCalledWith(
+    'expand-task',
+    expect.objectContaining({ hasCodebaseAnalysis: true, projectRoot: '/mock/project/root' }),
+    expect.any(String)
+  );
+});

scripts/modules/task-manager/analyze-task-complexity.js (5)

295-301: Stop using raw fs. for JSON; use readJSON for consistency and error handling.*
Per guidelines, prefer readJSON/writeJSON over fs.readFileSync/existsSync parsing.

Apply:

- if (fs.existsSync(outputPath)) {
-   existingReport = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+ try {
+   existingReport = readJSON(outputPath, projectRoot, tag);
+   if (existingReport) {
+     reportLog(`Found existing complexity report at ${outputPath}`, 'info');
+   }
+ } catch (_) {
+   existingReport = null;
+ }

---

355-360: Use writeJSON for reports; avoid fs.writeFileSync.
Keeps IO consistent, tag-aware, and centralized.

- fs.writeFileSync(
-   outputPath,
-   JSON.stringify(emptyReport, null, '\t'),
-   'utf8'
- );
+ writeJSON(outputPath, emptyReport, projectRoot, tag);

- fs.writeFileSync(outputPath, JSON.stringify(report, null, '\t'), 'utf8');
+ writeJSON(outputPath, report, projectRoot, tag);

Also applies to: 601-603

---

493-505: Add Zod validation for parsed analysis array.
We parse untrusted JSON; validate shape to avoid downstream surprises.

+ import { z } from 'zod';
...
- complexityAnalysis = JSON.parse(cleanedResponse);
+ const parsed = JSON.parse(cleanedResponse);
+ const AnalysisItem = z.object({
+   taskId: z.number().int().positive(),
+   taskTitle: z.string().min(1),
+   complexityScore: z.number().int().min(1).max(10),
+   recommendedSubtasks: z.number().int().min(0),
+   expansionPrompt: z.string().min(1),
+   reasoning: z.string().min(1)
+ });
+ const AnalysisArray = z.array(AnalysisItem);
+ const result = AnalysisArray.safeParse(parsed);
+ if (!result.success) {
+   throw new Error('Validation failed for complexity analysis JSON');
+ }
+ complexityAnalysis = result.data;

---

416-418: Nit: update stale comment referring to "Claude Code".
This module now uses capability gating.

- // Check if Claude Code is being used as the provider
+ // Check if a provider with codebase analysis capability is being used

---

714-714: Avoid process.exit in a module; let callers decide exit behavior.
Keeps this core function reusable in MCP/CLI/tests.

-       process.exit(1);
+       throw error;

scripts/modules/task-manager/expand-task.js (6)

464-474: Use the combinedAdditionalContext you built; it’s currently unused.
Right now, additionalContext excludes gathered/complexity context.

- let combinedAdditionalContext = '';
+ let combinedAdditionalContext = '';
  if (additionalContext || complexityReasoningContext) {
    combinedAdditionalContext =
      `\n\n${additionalContext}${complexityReasoningContext}`.trim();
  }
  if (gatheredContext) {
    combinedAdditionalContext =
      `${combinedAdditionalContext}\n\n# Project Context\n\n${gatheredContext}`.trim();
  }
...
- const promptParams = {
+ const promptParams = {
    task: task,
    subtaskCount: finalSubtaskCount,
    nextSubtaskId: nextSubtaskId,
-   additionalContext: additionalContext,
+   additionalContext: combinedAdditionalContext,
    complexityReasoningContext: complexityReasoningContext,
    gatheredContext: gatheredContextText || '',
    useResearch: useResearch,
    expansionPrompt: expansionPromptText || undefined,
    hasCodebaseAnalysis: hasCodebaseAnalysisCapability,
    projectRoot: projectRoot || ''
  };

Also applies to: 500-511

---

179-191: Incomplete advanced JSON extraction; consts prevent brace counting and no fallback implemented.
This path runs when simple parse fails; current code won’t repair JSON.

- const targetPattern = '{"subtasks":';
- const patternStartIndex = jsonToParse.indexOf(targetPattern);
- if (patternStartIndex !== -1) {
-   const openBraces = 0;
-   const firstBraceFound = false;
-   const extractedJsonBlock = '';
-   // ... (loop for brace counting as before) ...
- } else {
-   // ... (fallback to last '{' and '}' if targetPattern not found) ...
- }
+ const targetPattern = '{"subtasks":';
+ const patternStartIndex = jsonToParse.indexOf(targetPattern);
+ if (patternStartIndex !== -1) {
+   let openBraces = 0;
+   let started = false;
+   let buf = '';
+   for (let i = patternStartIndex; i < jsonToParse.length; i++) {
+     const ch = jsonToParse[i];
+     if (ch === '{') {
+       openBraces++;
+       started = true;
+     } else if (ch === '}') {
+       openBraces--;
+     }
+     if (started) buf += ch;
+     if (started && openBraces === 0) break;
+   }
+   if (buf && openBraces === 0) {
+     jsonToParse = buf;
+   }
+ } else {
+   // Fallback: take the longest balanced {...} block
+   const first = jsonToParse.indexOf('{');
+   const last = jsonToParse.lastIndexOf('}');
+   if (first !== -1 && last > first) {
+     jsonToParse = jsonToParse.slice(first, last + 1);
+   }
+ }

---

319-320: Align generateTextService.outputType to 'mcp' | 'cli' (not 'json' | 'text').
Avoids provider-conditional behavior drift between modules.

- const outputFormat = mcpLog ? 'json' : 'text';
+ const outputFormat = mcpLog ? 'json' : 'text';
+ const serviceOutputType = mcpLog ? 'mcp' : 'cli';
...
-   outputType: outputFormat
+   outputType: serviceOutputType

Also applies to: 565-566

---

396-423: Guard undefined complexityReportPath; compute a tag-aware default.
fs.existsSync(undefined) throws; derive path with getTagAwareFilePath.

- logger.info(
-   `Looking for complexity report at: ${complexityReportPath}${tag !== 'master' ? ` (tag-specific for '${tag}')` : ''}`
- );
+ const resolvedReportPath =
+   complexityReportPath ||
+   getTagAwareFilePath(COMPLEXITY_REPORT_FILE, projectRoot, tag);
+ logger.info(
+   `Looking for complexity report at: ${resolvedReportPath}${tag && tag !== 'master' ? ` (tag-specific for '${tag}')` : ''}`
+ );
...
- if (fs.existsSync(complexityReportPath)) {
-   const complexityReport = readJSON(complexityReportPath);
+ if (fs.existsSync(resolvedReportPath)) {
+   const complexityReport = readJSON(resolvedReportPath, projectRoot, tag);

---

588-593: Fix parse-error message check; current string never matches.
Ensures raw AI response is logged in debug when parsing fails.

- if (
-   error.message.includes('Failed to parse valid subtasks') &&
-   getDebugFlag(session)
- ) {
+ if (
+   (error.message.includes('Failed to parse JSON response object') ||
+     error.message.includes('subtasks')) &&
+   getDebugFlag(session)
+ ) {

---

402-406: Optional: pass projectRoot/tag to readJSON for consistency.

- const complexityReport = readJSON(resolvedReportPath);
+ const complexityReport = readJSON(resolvedReportPath, projectRoot, tag);

src/prompts/update-task.json (2)

3-9: Version/metadata should reflect the public parameter addition.

Bump version to 1.1.0 and update the “updated” timestamp.

Apply:

-  "version": "1.0.0",
+  "version": "1.1.0",
@@
-    "updated": "2024-01-01T00:00:00Z",
+    "updated": "2025-08-28T00:00:00Z",

---

1-71: Remember to update tasks.json via windsufrules when prompt intent changes.

Per the repo convention, run: node scripts/dev.js update --from= --prompt="Rename isClaudeCode→hasCodebaseAnalysis and add projectRoot context to update-task prompt."

src/prompts/update-subtask.json (2)

3-9: Version/metadata should reflect the parameter rename.

Bump to 1.1.0 and refresh “updated”.

-  "version": "1.0.0",
+  "version": "1.1.0",
@@
-    "updated": "2024-01-01T00:00:00Z",
+    "updated": "2025-08-28T00:00:00Z",

---

27-32: Required + default on currentDetails is redundant.

If required is true, callers must supply it; otherwise rely on default. Pick one to simplify schema.

-      "required": true,
-      "default": "(No existing details)",
+      "required": false,
+      "default": "(No existing details)",