mstro-app 0.4.35 → 0.4.37

package/server/cli/improvisation-session-manager.ts

@@ -131,9 +131,10 @@ export class ImprovisationSessionManager extends EventEmitter {
 
   // ========== Main Execution ==========
 
-  async executePrompt(userPrompt: string, attachments?: FileAttachment[], options?: { workingDir?: string; isAutoContinue?: boolean }): Promise<MovementRecord> {
+  async executePrompt(userPrompt: string, attachments?: FileAttachment[], options?: { workingDir?: string; isAutoContinue?: boolean; displayPrompt?: string }): Promise<MovementRecord> {
     const _execStart = Date.now();
     const isAutoContinue = options?.isAutoContinue ?? false;
+    const displayPrompt = options?.displayPrompt ?? userPrompt;
     this._isExecuting = true;
     this._cancelled = false;
     this._cancelCompleteEmitted = false;
@@ -145,9 +146,9 @@ export class ImprovisationSessionManager extends EventEmitter {
     this.executionEventLog = [];
 
     const sequenceNumber = this.history.movements.length + 1;
-    this._currentUserPrompt = userPrompt;
+    this._currentUserPrompt = displayPrompt;
     this._currentSequenceNumber = sequenceNumber;
-    this.emit('onMovementStart', sequenceNumber, userPrompt, isAutoContinue);
+    this.emit('onMovementStart', sequenceNumber, displayPrompt, isAutoContinue);
     trackEvent(AnalyticsEvents.IMPROVISE_PROMPT_RECEIVED, {
       prompt_length: userPrompt.length,
       has_attachments: !!(attachments && attachments.length > 0),
@@ -162,7 +163,7 @@ export class ImprovisationSessionManager extends EventEmitter {
     const pendingMovement: MovementRecord = {
       id: `prompt-${sequenceNumber}`,
       sequenceNumber,
-      userPrompt,
+      userPrompt: displayPrompt,
       timestamp: new Date().toISOString(),
       tokensUsed: 0,
       summary: '',
@@ -176,7 +177,7 @@ export class ImprovisationSessionManager extends EventEmitter {
     try {
       this.executionEventLog.push({
         type: 'movementStart',
-        data: { sequenceNumber, prompt: userPrompt, timestamp: Date.now(), executionStartTimestamp: this._executionStartTimestamp },
+        data: { sequenceNumber, prompt: displayPrompt, timestamp: Date.now(), executionStartTimestamp: this._executionStartTimestamp },
         timestamp: Date.now(),
       });
 
@@ -201,7 +202,7 @@ export class ImprovisationSessionManager extends EventEmitter {
       let result = await this.runRetryLoop(state, sequenceNumber, promptWithAttachments, imageAttachments, options?.workingDir);
 
       if (this._cancelled) {
-        return this.handleCancelledExecution(result, userPrompt, sequenceNumber, _execStart);
+        return this.handleCancelledExecution(result, displayPrompt, sequenceNumber, _execStart);
       }
 
       if (state.contextLost) this.claudeSessionId = undefined;
@@ -209,7 +210,7 @@ export class ImprovisationSessionManager extends EventEmitter {
       this.captureSessionAndSurfaceErrors(result);
       this.isFirstPrompt = false;
 
-      const movement = this.buildMovementRecord(result, userPrompt, sequenceNumber, _execStart, state.retryLog, isAutoContinue);
+      const movement = this.buildMovementRecord(result, displayPrompt, sequenceNumber, _execStart, state.retryLog, isAutoContinue);
       this.handleConflicts(result);
       this.persistMovement(movement);
 
@@ -218,44 +219,12 @@ export class ImprovisationSessionManager extends EventEmitter {
       this.executionEventLog = [];
 
       this.emitMovementComplete(movement, result, _execStart, sequenceNumber);
-
-      if (this.shouldAutoContinue(result, userPrompt)) {
-        this.scheduleAutoContinue();
-      }
+      this.maybeAutoContinue(result, userPrompt);
 
       return movement;
 
     } catch (error: unknown) {
-      this._isExecuting = false;
-      this._executionStartTimestamp = undefined;
-      this.executionEventLog = [];
-      this.currentRunner = null;
-
-      // Update the pending movement with error info so it's not lost
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const errorMovement: MovementRecord = {
-        id: `prompt-${sequenceNumber}`,
-        sequenceNumber,
-        userPrompt,
-        timestamp: new Date().toISOString(),
-        tokensUsed: 0,
-        summary: '',
-        filesModified: [],
-        errorOutput: errorMessage,
-        durationMs: Date.now() - _execStart,
-      };
-      this.persistMovement(errorMovement);
-
-      this.emit('onMovementError', error);
-      trackEvent(AnalyticsEvents.IMPROVISE_MOVEMENT_ERROR, {
-        error_message: errorMessage.slice(0, 200),
-        sequence_number: sequenceNumber,
-        duration_ms: Date.now() - _execStart,
-        model: this.options.model || 'default',
-      });
-      this.queueOutput(`\n❌ Error: ${errorMessage}\n`);
-      this.flushOutputQueue();
-      throw error;
+      this.handleExecutionError(error, displayPrompt, sequenceNumber, _execStart);
     } finally {
       this.flushOutputQueue();
     }
@@ -410,6 +379,43 @@ export class ImprovisationSessionManager extends EventEmitter {
     return cancelledMovement;
   }
 
+  private handleExecutionError(
+    error: unknown,
+    displayPrompt: string,
+    sequenceNumber: number,
+    execStart: number,
+  ): never {
+    this._isExecuting = false;
+    this._executionStartTimestamp = undefined;
+    this.executionEventLog = [];
+    this.currentRunner = null;
+
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorMovement: MovementRecord = {
+      id: `prompt-${sequenceNumber}`,
+      sequenceNumber,
+      userPrompt: displayPrompt,
+      timestamp: new Date().toISOString(),
+      tokensUsed: 0,
+      summary: '',
+      filesModified: [],
+      errorOutput: errorMessage,
+      durationMs: Date.now() - execStart,
+    };
+    this.persistMovement(errorMovement);
+
+    this.emit('onMovementError', error);
+    trackEvent(AnalyticsEvents.IMPROVISE_MOVEMENT_ERROR, {
+      error_message: errorMessage.slice(0, 200),
+      sequence_number: sequenceNumber,
+      duration_ms: Date.now() - execStart,
+      model: this.options.model || 'default',
+    });
+    this.queueOutput(`\n❌ Error: ${errorMessage}\n`);
+    this.flushOutputQueue();
+    throw error;
+  }
+
   // ========== Post-Execution Helpers ==========
 
   private captureSessionAndSurfaceErrors(result: HeadlessRunResult): void {
@@ -493,6 +499,15 @@ export class ImprovisationSessionManager extends EventEmitter {
   private _autoContinuePending = false;
   private static readonly MAX_AUTO_CONTINUES = 1;
 
+  private maybeAutoContinue(result: HeadlessRunResult, userPrompt: string): void {
+    const isStallKill = !this._cancelled && !!result.signalName;
+    if (isStallKill && this._autoContinueCount < ImprovisationSessionManager.MAX_AUTO_CONTINUES) {
+      this.scheduleAutoContinue('Process stalled');
+    } else if (this.shouldAutoContinue(result, userPrompt)) {
+      this.scheduleAutoContinue();
+    }
+  }
+
   private shouldAutoContinue(result: HeadlessRunResult, _userPrompt: string): boolean {
     if (this._autoContinueCount >= ImprovisationSessionManager.MAX_AUTO_CONTINUES) return false;
     if (this._cancelled) return false;
@@ -510,10 +525,11 @@ export class ImprovisationSessionManager extends EventEmitter {
     return thinkingLen >= responseLen * 3;
   }
 
-  private scheduleAutoContinue(): void {
+  private scheduleAutoContinue(reason?: string): void {
     this._autoContinueCount++;
     this._autoContinuePending = true;
-    this.queueOutput('\n⟳ Response appears incomplete — auto-continuing…\n');
+    const msg = reason || 'Response appears incomplete';
+    this.queueOutput(`\n[[MSTRO_AUTO_CONTINUE]] ${msg} — resuming session (retry ${this._autoContinueCount}/${ImprovisationSessionManager.MAX_AUTO_CONTINUES}).\n`);
     this.flushOutputQueue();
 
     setImmediate(() => {

package/server/services/websocket/git-worktree-handlers.ts

@@ -391,6 +391,30 @@ async function detectMergeConflicts(mainPath: string): Promise<string[]> {
   return result.stdout.trim().split('\n').filter(f => f.trim());
 }
 
+async function removeWorktreeWithFallback(
+  mainPath: string,
+  worktreePath: string,
+): Promise<{ success: boolean; warning?: string }> {
+  const removeResult = await executeGitCommand(['worktree', 'remove', worktreePath], mainPath);
+  if (removeResult.exitCode === 0) return { success: true };
+  const forceResult = await executeGitCommand(['worktree', 'remove', '--force', worktreePath], mainPath);
+  if (forceResult.exitCode === 0) return { success: true };
+  return { success: false, warning: `Failed to remove worktree: ${forceResult.stderr || 'unknown error'}` };
+}
+
+async function deleteBranchAfterMerge(
+  mainPath: string,
+  branchName: string,
+  strategy: string,
+): Promise<string | undefined> {
+  const deleteFlag = strategy === 'squash' ? '-D' : '-d';
+  const result = await executeGitCommand(['branch', deleteFlag, branchName], mainPath);
+  if (result.exitCode !== 0) {
+    return `Failed to delete branch: ${result.stderr || 'unknown error'}`;
+  }
+  return undefined;
+}
+
 async function cleanupAfterMerge(
   mainPath: string,
   sourceBranch: string,
@@ -405,25 +429,17 @@ async function cleanupAfterMerge(
     const wtList = await executeGitCommand(['worktree', 'list', '--porcelain'], mainPath);
     const worktreePath = findWorktreePathForBranch(wtList.stdout, sourceBranch);
     if (worktreePath && worktreePath !== mainPath) {
-      const removeResult = await executeGitCommand(['worktree', 'remove', worktreePath], mainPath);
-      if (removeResult.exitCode !== 0) {
-        const forceResult = await executeGitCommand(['worktree', 'remove', '--force', worktreePath], mainPath);
-        if (forceResult.exitCode !== 0) {
-          warnings.push(`Failed to remove worktree: ${forceResult.stderr || 'unknown error'}`);
-        } else {
-          removedWorktreePath = worktreePath;
-        }
-      } else {
+      const result = await removeWorktreeWithFallback(mainPath, worktreePath);
+      if (result.success) {
         removedWorktreePath = worktreePath;
+      } else if (result.warning) {
+        warnings.push(result.warning);
       }
     }
   }
   if (deleteBranch) {
-    const deleteFlag = strategy === 'squash' ? '-D' : '-d';
-    const branchResult = await executeGitCommand(['branch', deleteFlag, sourceBranch], mainPath);
-    if (branchResult.exitCode !== 0) {
-      warnings.push(`Failed to delete branch: ${branchResult.stderr || 'unknown error'}`);
-    }
+    const warning = await deleteBranchAfterMerge(mainPath, sourceBranch, strategy);
+    if (warning) warnings.push(warning);
   }
   await executeGitCommand(['worktree', 'prune'], mainPath);
   return { warnings, removedWorktreePath };

package/server/services/websocket/session-handlers.ts

@@ -5,6 +5,7 @@ import type { FileAttachment, ImprovisationSessionManager } from '../../cli/impr
 import { getModel } from '../settings.js';
 import type { HandlerContext } from './handler-context.js';
 import { runQualityScan } from './quality-service.js';
+import { resolveSkillPrompt } from './skill-handlers.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
 // Re-export from extracted modules for backward compatibility
@@ -191,7 +192,22 @@ export function handleSessionMessage(ctx: HandlerContext, ws: WSContext, msg: We
       const session = requireSession(ctx, ws, tabId);
       const worktreeDir = ctx.gitDirectories.get(tabId);
       const attachments = mergePreUploadedAttachments(ctx, tabId, msg.data.attachments);
-      session.executePrompt(msg.data.prompt, attachments, { workingDir: worktreeDir });
+
+      // Resolve slash commands (e.g. "/code-review") to their SKILL.md prompt content.
+      // Claude Code's -p headless mode doesn't support skills natively, so we load
+      // the skill's instructions and pass them as the actual prompt.
+      const rawPrompt = msg.data.prompt as string;
+      const effectiveDir = worktreeDir || session.getSessionInfo().workingDir;
+      const resolved = resolveSkillPrompt(rawPrompt, effectiveDir);
+
+      session.executePrompt(
+        resolved ? resolved.prompt : rawPrompt,
+        attachments,
+        {
+          workingDir: worktreeDir,
+          displayPrompt: resolved ? rawPrompt : undefined,
+        },
+      );
       break;
     }
     case 'cancel': {

package/server/services/websocket/skill-handlers.ts

@@ -1,7 +1,9 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
 // Licensed under the MIT License. See LICENSE file for details.
 
+import { execSync } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { findSkillsDir } from '../../utils/paths.js';
@@ -10,6 +12,22 @@ import type { SkillEntry, WSContext } from './types.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const SYSTEM_AGENTS_DIR = join(__dirname, '..', 'plan', 'agents');
+const USER_SKILLS_DIR = join(homedir(), '.claude', 'skills');
+
+const PLATFORM_COMMANDS: SkillEntry[] = [
+	{
+		name: 'board',
+		displayName: '/board',
+		description: 'Convert the current chat conversation into a PM board with issues.',
+		source: 'platform',
+	},
+	{
+		name: 'ship',
+		displayName: '/ship',
+		description: 'Convert chat into a PM board and auto-implement with AI agents.',
+		source: 'platform',
+	},
+];
 
 function parseFrontmatter(content: string): Record<string, string> {
 	if (!content.startsWith('---')) return {};
@@ -52,6 +70,32 @@ function scanProjectSkills(skillsDir: string): SkillEntry[] {
 	return entries;
 }
 
+function tryReadSkill(skillFile: string): Record<string, string> | null {
+	if (!existsSync(skillFile)) return null;
+	try {
+		return parseFrontmatter(readFileSync(skillFile, 'utf-8'));
+	} catch { return null; }
+}
+
+function scanUserSkills(userSkillsDir: string, seen: Set<string>): SkillEntry[] {
+	if (!existsSync(userSkillsDir)) return [];
+	const entries: SkillEntry[] = [];
+	for (const name of readdirSync(userSkillsDir, { withFileTypes: true })) {
+		if (!name.isDirectory() || seen.has(name.name)) continue;
+		const fm = tryReadSkill(join(userSkillsDir, name.name, 'SKILL.md'));
+		if (!fm || fm['user-invocable'] === 'false') continue;
+		const skillName = fm.name || name.name;
+		if (seen.has(skillName)) continue;
+		entries.push({
+			name: skillName,
+			displayName: `/${skillName}`,
+			description: fm.description || '',
+			source: 'user',
+		});
+	}
+	return entries;
+}
+
 function scanSystemAgents(agentsDir: string, seen: Set<string>): SkillEntry[] {
 	if (!existsSync(agentsDir)) return [];
 	const entries: SkillEntry[] = [];
@@ -75,16 +119,229 @@ function scanSystemAgents(agentsDir: string, seen: Set<string>): SkillEntry[] {
 }
 
 export function handleListSkills(ctx: HandlerContext, ws: WSContext, workingDir: string): void {
-	const skills: SkillEntry[] = [];
+	const skills: SkillEntry[] = [...PLATFORM_COMMANDS];
+	const seen = new Set(skills.map(s => s.name));
 
 	const projectSkillsDir = findSkillsDir(workingDir);
 	if (projectSkillsDir) {
-		skills.push(...scanProjectSkills(projectSkillsDir));
+		const projectSkills = scanProjectSkills(projectSkillsDir);
+		for (const s of projectSkills) {
+			if (!seen.has(s.name)) {
+				skills.push(s);
+				seen.add(s.name);
+			}
+		}
 	}
 
-	const seen = new Set(skills.map(s => s.name));
+	skills.push(...scanUserSkills(USER_SKILLS_DIR, seen));
+
+	for (const s of skills) seen.add(s.name);
 	skills.push(...scanSystemAgents(SYSTEM_AGENTS_DIR, seen));
 
 	skills.sort((a, b) => a.name.localeCompare(b.name));
 	ctx.send(ws, { type: 'skillsList', data: { skills } });
 }
+
+/**
+ * Extract prompt content from a SKILL.md file (everything after the frontmatter).
+ */
+function extractSkillContent(fileContent: string): string {
+	if (!fileContent.startsWith('---')) return fileContent;
+	const endIdx = fileContent.indexOf('---', 3);
+	if (endIdx === -1) return fileContent;
+	return fileContent.slice(endIdx + 3).trim();
+}
+
+interface SkillFile {
+	content: string;
+	skillDir: string;
+}
+
+/**
+ * Find and read a skill's SKILL.md by name. Checks project skills first, then system agents.
+ * Returns the raw file content and the skill directory, or null if not found.
+ */
+function findSkillContent(skillName: string, workingDir: string): SkillFile | null {
+	// Project skills: .claude/skills/<name>/SKILL.md
+	const projectSkillsDir = findSkillsDir(workingDir);
+	if (projectSkillsDir) {
+		const skillDir = join(projectSkillsDir, skillName);
+		const skillFile = join(skillDir, 'SKILL.md');
+		if (existsSync(skillFile)) {
+			try {
+				return { content: readFileSync(skillFile, 'utf-8'), skillDir };
+			} catch { /* fall through */ }
+		}
+	}
+
+	// User skills: ~/.claude/skills/<name>/SKILL.md
+	const userSkillDir = join(USER_SKILLS_DIR, skillName);
+	const userSkillFile = join(userSkillDir, 'SKILL.md');
+	if (existsSync(userSkillFile)) {
+		try {
+			return { content: readFileSync(userSkillFile, 'utf-8'), skillDir: userSkillDir };
+		} catch { /* fall through */ }
+	}
+
+	// System agents: <agents-dir>/<name>.md
+	const agentFile = join(SYSTEM_AGENTS_DIR, `${skillName}.md`);
+	if (existsSync(agentFile)) {
+		try {
+			return { content: readFileSync(agentFile, 'utf-8'), skillDir: SYSTEM_AGENTS_DIR };
+		} catch { /* fall through */ }
+	}
+
+	return null;
+}
+
+/**
+ * Fill in {{mustache}} template variables in skill content.
+ */
+function fillTemplateVariables(content: string, vars: Record<string, string>): string {
+	let result = content;
+	for (const [key, value] of Object.entries(vars)) {
+		result = result.replaceAll(`{{${key}}}`, value);
+	}
+	return result;
+}
+
+/**
+ * Parse shell-style quoted arguments: `"hello world" second` → ['hello world', 'second']
+ */
+function parseShellArgs(argsStr: string): string[] {
+	const args: string[] = [];
+	let current = '';
+	let inSingle = false;
+	let inDouble = false;
+
+	for (let i = 0; i < argsStr.length; i++) {
+		const ch = argsStr[i];
+		if (ch === "'" && !inDouble) { inSingle = !inSingle; continue; }
+		if (ch === '"' && !inSingle) { inDouble = !inDouble; continue; }
+		if (ch === ' ' && !inSingle && !inDouble) {
+			if (current) { args.push(current); current = ''; }
+			continue;
+		}
+		current += ch;
+	}
+	if (current) args.push(current);
+	return args;
+}
+
+/**
+ * Replace $ARGUMENTS, $ARGUMENTS[N], $0, $1, etc. with actual argument values.
+ */
+function fillArgumentVariables(content: string, userArgs: string): string {
+	let result = content;
+	const parsedArgs = parseShellArgs(userArgs);
+
+	// $ARGUMENTS[N] and $N — indexed access (must be replaced before $ARGUMENTS)
+	result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_, n) => parsedArgs[parseInt(n, 10)] ?? '');
+	result = result.replace(/\$(\d+)\b/g, (_, n) => parsedArgs[parseInt(n, 10)] ?? '');
+
+	// $ARGUMENTS — full argument string
+	result = result.replaceAll('$ARGUMENTS', userArgs);
+
+	return result;
+}
+
+/**
+ * Execute inline shell commands: !`command` → command output.
+ * Also handles fenced ```! blocks for multi-line commands.
+ * Runs in the skill's working directory with a short timeout.
+ */
+function executeInlineShellCommands(content: string, workingDir: string): string {
+	// Fenced ```! blocks — multi-line shell execution
+	let result = content.replace(/```!\n([\s\S]*?)```/g, (_, block: string) => {
+		const cmd = block.trim();
+		try {
+			return execSync(cmd, { cwd: workingDir, timeout: 10_000, encoding: 'utf-8' }).trim();
+		} catch {
+			return `[shell command failed: ${cmd.split('\n')[0]}]`;
+		}
+	});
+
+	// Inline !`command` syntax
+	result = result.replace(/!`([^`]+)`/g, (_, cmd: string) => {
+		try {
+			return execSync(cmd.trim(), { cwd: workingDir, timeout: 10_000, encoding: 'utf-8' }).trim();
+		} catch {
+			return `[shell command failed: ${cmd.trim()}]`;
+		}
+	});
+
+	return result;
+}
+
+export interface ResolvedSkill {
+	/** The resolved prompt to send to the headless runner */
+	prompt: string;
+	/** The original skill name */
+	skillName: string;
+	/** Any user arguments after the skill name */
+	userArgs: string;
+}
+
+/**
+ * Resolve a slash command (e.g. "/code-review src/") into the skill's prompt content.
+ * Returns null if the prompt is not a slash command or the skill is not found.
+ *
+ * Implements the Claude Code skill spec:
+ * - Strips YAML frontmatter, extracts body as the prompt
+ * - Fills {{mustache}} template variables (dirPath, cliFindingsSection)
+ * - Substitutes $ARGUMENTS, $ARGUMENTS[N], $0/$1 with user-provided arguments
+ * - Executes inline shell commands (!`cmd` and ```! blocks)
+ * - Replaces ${CLAUDE_SKILL_DIR} with the skill's directory path
+ * - Appends user args as "ARGUMENTS: ..." if $ARGUMENTS is not used in the content
+ */
+function parseSlashCommand(trimmed: string): { skillName: string; userArgs: string } | null {
+	if (!trimmed.startsWith('/')) return null;
+	const spaceIdx = trimmed.indexOf(' ');
+	const skillName = spaceIdx === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
+	const userArgs = spaceIdx === -1 ? '' : trimmed.slice(spaceIdx + 1).trim();
+	return skillName ? { skillName, userArgs } : null;
+}
+
+const CLAUDE_SKILL_DIR_RE = /\$\{CLAUDE_SKILL_DIR}/g;
+const CLAUDE_SESSION_ID_RE = /\$\{CLAUDE_SESSION_ID}/g;
+
+function processSkillContent(rawContent: string, userArgs: string, skillDir: string, workingDir: string): string {
+	let content = extractSkillContent(rawContent);
+
+	content = fillTemplateVariables(content, {
+		dirPath: userArgs || workingDir,
+		cliFindingsSection: '',
+	});
+
+	const hasArgumentsPlaceholder = /\$ARGUMENTS|\$\d+\b/.test(content);
+	if (hasArgumentsPlaceholder) {
+		content = fillArgumentVariables(content, userArgs);
+	}
+
+	content = content.replace(CLAUDE_SKILL_DIR_RE, skillDir);
+	content = content.replace(CLAUDE_SESSION_ID_RE, `mstro-${Date.now()}`);
+
+	if (/!`[^`]+`/.test(content) || /```!\n/.test(content)) {
+		content = executeInlineShellCommands(content, workingDir);
+	}
+
+	if (userArgs && !hasArgumentsPlaceholder && !rawContent.includes('{{dirPath}}')) {
+		content = `${content}\n\nARGUMENTS: ${userArgs}`;
+	}
+
+	return content;
+}
+
+export function resolveSkillPrompt(prompt: string, workingDir: string): ResolvedSkill | null {
+	const parsed = parseSlashCommand(prompt.trim());
+	if (!parsed) return null;
+
+	const found = findSkillContent(parsed.skillName, workingDir);
+	if (!found) return null;
+
+	const fm = parseFrontmatter(found.content);
+	if (fm['user-invocable'] === 'false') return null;
+
+	const skillPrompt = processSkillContent(found.content, parsed.userArgs, found.skillDir, workingDir);
+	return { prompt: skillPrompt, skillName: parsed.skillName, userArgs: parsed.userArgs };
+}