@aion0/forge 0.4.16 → 0.5.0

package/lib/workspace/persistence.ts

@@ -0,0 +1,310 @@
+/**
+ * Workspace Persistence — save/load workspace state to disk.
+ *
+ * Storage layout:
+ *   ~/.forge/workspaces/{workspace-id}/
+ *     state.json            — workspace config, agent states, node positions, bus log
+ *     agents/{agent-id}/
+ *       logs.jsonl           — append-only execution log
+ *       history.json         — conversation history snapshot
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, rmSync, renameSync } from 'node:fs';
+import { writeFile, appendFile, mkdir, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import type { WorkspaceState, AgentState, BusMessage, WorkspaceAgentConfig } from './types';
+import type { TaskLogEntry } from '@/src/types';
+
+// ─── Paths ───────────────────────────────────────────────
+
+const WORKSPACES_ROOT = join(homedir(), '.forge', 'workspaces');
+
+function workspaceDir(workspaceId: string): string {
+  return join(WORKSPACES_ROOT, workspaceId);
+}
+
+function agentDir(workspaceId: string, agentId: string): string {
+  return join(workspaceDir(workspaceId), 'agents', agentId);
+}
+
+function stateFile(workspaceId: string): string {
+  return join(workspaceDir(workspaceId), 'state.json');
+}
+
+function agentLogFile(workspaceId: string, agentId: string): string {
+  return join(agentDir(workspaceId, agentId), 'logs.jsonl');
+}
+
+function agentHistoryFile(workspaceId: string, agentId: string): string {
+  return join(agentDir(workspaceId, agentId), 'history.json');
+}
+
+// ─── Save ────────────────────────────────────────────────
+
+export async function saveWorkspace(state: WorkspaceState): Promise<void> {
+  const dir = workspaceDir(state.id);
+  mkdirSync(dir, { recursive: true }); // sync mkdir is fine (fast, cached by OS)
+
+  const stateToSave: WorkspaceState = {
+    ...state,
+    agentStates: Object.fromEntries(
+      Object.entries(state.agentStates).map(([id, s]) => [id, {
+        ...s,
+        history: [],
+        logFile: agentLogFile(state.id, id),
+      }])
+    ),
+    updatedAt: Date.now(),
+  };
+
+  // Atomic write — write to temp file, then rename (prevents 0-byte on crash)
+  const target = stateFile(state.id);
+  const tmp = target + '.tmp';
+  await writeFile(tmp, JSON.stringify(stateToSave, null, 2), 'utf-8');
+  await rename(tmp, target);
+
+  // Save per-agent history in parallel
+  await Promise.all(
+    Object.entries(state.agentStates).map(([agentId, agentState]) =>
+      saveAgentHistory(state.id, agentId, agentState)
+    )
+  );
+}
+
+async function saveAgentHistory(workspaceId: string, agentId: string, state: AgentState): Promise<void> {
+  const dir = agentDir(workspaceId, agentId);
+  await mkdir(dir, { recursive: true });
+  await writeFile(agentHistoryFile(workspaceId, agentId), JSON.stringify(state.history, null, 2), 'utf-8');
+}
+
+/** Synchronous save — used during shutdown to ensure data is written before process exits */
+export function saveWorkspaceSync(state: WorkspaceState): void {
+  const dir = workspaceDir(state.id);
+  mkdirSync(dir, { recursive: true });
+
+  const stateToSave: WorkspaceState = {
+    ...state,
+    agentStates: Object.fromEntries(
+      Object.entries(state.agentStates).map(([id, s]) => [id, {
+        ...s,
+        history: [],
+        logFile: agentLogFile(state.id, id),
+      }])
+    ),
+    updatedAt: Date.now(),
+  };
+
+  // Atomic: write temp → rename
+  const target = stateFile(state.id);
+  const tmp = target + '.tmp';
+  writeFileSync(tmp, JSON.stringify(stateToSave, null, 2), 'utf-8');
+  renameSync(tmp, target);
+
+  // Save per-agent history
+  for (const [agentId, agentState] of Object.entries(state.agentStates)) {
+    const adir = agentDir(state.id, agentId);
+    mkdirSync(adir, { recursive: true });
+    writeFileSync(agentHistoryFile(state.id, agentId), JSON.stringify(agentState.history, null, 2), 'utf-8');
+  }
+}
+
+// ─── Append Log ──────────────────────────────────────────
+
+/** Append a single log entry to an agent's JSONL log file (async) */
+export async function appendAgentLog(workspaceId: string, agentId: string, entry: TaskLogEntry): Promise<void> {
+  const dir = agentDir(workspaceId, agentId);
+  await mkdir(dir, { recursive: true });
+  await appendFile(agentLogFile(workspaceId, agentId), JSON.stringify(entry) + '\n', 'utf-8');
+}
+
+// ─── Load ────────────────────────────────────────────────
+
+export function loadWorkspace(workspaceId: string): WorkspaceState | null {
+  const file = stateFile(workspaceId);
+  if (!existsSync(file)) return null;
+
+  try {
+    const raw = readFileSync(file, 'utf-8');
+    if (!raw || raw.trim().length === 0) {
+      console.error(`[persistence] Empty state file for workspace ${workspaceId}`);
+      return null;
+    }
+    const state: WorkspaceState = JSON.parse(raw);
+
+    // Restore per-agent history
+    for (const [agentId, agentState] of Object.entries(state.agentStates)) {
+      const histFile = agentHistoryFile(workspaceId, agentId);
+      if (existsSync(histFile)) {
+        try {
+          agentState.history = JSON.parse(readFileSync(histFile, 'utf-8'));
+        } catch {
+          agentState.history = [];
+        }
+      }
+
+      // Migrate old status field to new two-layer model
+      if ('status' in agentState && !('smithStatus' in agentState)) {
+        const oldStatus = (agentState as any).status;
+        (agentState as any).smithStatus = 'down';
+        (agentState as any).mode = (agentState as any).runMode || 'auto';
+        (agentState as any).taskStatus = (oldStatus === 'running' || oldStatus === 'listening') ? 'idle' :
+                       (oldStatus === 'interrupted') ? 'idle' :
+                       (oldStatus === 'waiting_approval') ? 'idle' :
+                       (oldStatus === 'paused') ? 'idle' :
+                       oldStatus;
+        delete (agentState as any).status;
+        delete (agentState as any).runMode;
+        delete (agentState as any).daemonMode;
+      }
+      // Mark running agents as idle (they were killed on shutdown)
+      if (agentState.taskStatus === 'running') {
+        agentState.taskStatus = 'idle';
+      }
+    }
+
+    // Migrate Input nodes: content → entries
+    for (const agent of state.agents) {
+      if (agent.type === 'input') {
+        if (!agent.entries) agent.entries = [];
+        if (agent.entries.length === 0 && agent.content) {
+          agent.entries.push({ content: agent.content, timestamp: state.updatedAt || Date.now() });
+        }
+      }
+    }
+
+    return state;
+  } catch {
+    return null;
+  }
+}
+
+// ─── List ────────────────────────────────────────────────
+
+export interface WorkspaceSummary {
+  id: string;
+  projectPath: string;
+  projectName: string;
+  agentCount: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export function listWorkspaces(): WorkspaceSummary[] {
+  if (!existsSync(WORKSPACES_ROOT)) return [];
+
+  const results: WorkspaceSummary[] = [];
+
+  for (const entry of readdirSync(WORKSPACES_ROOT, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const file = stateFile(entry.name);
+    if (!existsSync(file)) continue;
+
+    try {
+      const raw = readFileSync(file, 'utf-8');
+      const state: WorkspaceState = JSON.parse(raw);
+      results.push({
+        id: state.id,
+        projectPath: state.projectPath,
+        projectName: state.projectName,
+        agentCount: state.agents.length,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt,
+      });
+    } catch {
+      // Skip corrupted state files
+    }
+  }
+
+  return results.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+
+/** Find workspace by project path */
+export function findWorkspaceByProject(projectPath: string): WorkspaceState | null {
+  if (!existsSync(WORKSPACES_ROOT)) return null;
+
+  for (const entry of readdirSync(WORKSPACES_ROOT, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const file = stateFile(entry.name);
+    if (!existsSync(file)) continue;
+
+    try {
+      const raw = readFileSync(file, 'utf-8');
+      const state: WorkspaceState = JSON.parse(raw);
+      if (state.projectPath === projectPath) {
+        return loadWorkspace(state.id);
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+// ─── Delete ──────────────────────────────────────────────
+
+export function deleteWorkspace(workspaceId: string): boolean {
+  const dir = workspaceDir(workspaceId);
+  if (!existsSync(dir)) return false;
+  rmSync(dir, { recursive: true, force: true });
+  return true;
+}
+
+// ─── Read Agent Logs ─────────────────────────────────────
+
+/** Read the full JSONL log for an agent */
+export function readAgentLog(workspaceId: string, agentId: string): TaskLogEntry[] {
+  const file = agentLogFile(workspaceId, agentId);
+  if (!existsSync(file)) return [];
+
+  try {
+    const raw = readFileSync(file, 'utf-8');
+    return raw.split('\n').filter(Boolean).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean) as TaskLogEntry[];
+  } catch {
+    return [];
+  }
+}
+
+/** Read the last N log entries for an agent */
+export function readAgentLogTail(workspaceId: string, agentId: string, n = 20): TaskLogEntry[] {
+  const log = readAgentLog(workspaceId, agentId);
+  return log.slice(-n);
+}
+
+/** Clear agent log file */
+export function clearAgentLog(workspaceId: string, agentId: string): void {
+  const file = agentLogFile(workspaceId, agentId);
+  if (existsSync(file)) writeFileSync(file, '');
+}
+
+// ─── Auto-save timer ─────────────────────────────────────
+
+const saveTimers = new Map<string, NodeJS.Timeout>();
+
+/**
+ * Start periodic auto-save for a workspace.
+ * Calls `getState()` to get current state and saves it.
+ */
+export function startAutoSave(workspaceId: string, getState: () => WorkspaceState, intervalMs = 10_000): void {
+  stopAutoSave(workspaceId);
+  const timer = setInterval(() => {
+    try {
+      const state = getState();
+      saveWorkspace(state).catch(() => {});
+    } catch {
+      // Silently ignore save errors
+    }
+  }, intervalMs);
+  saveTimers.set(workspaceId, timer);
+}
+
+export function stopAutoSave(workspaceId: string): void {
+  const timer = saveTimers.get(workspaceId);
+  if (timer) {
+    clearInterval(timer);
+    saveTimers.delete(workspaceId);
+  }
+}

package/lib/workspace/presets.ts

@@ -0,0 +1,170 @@
+/**
+ * Preset agent templates — default roles with predefined steps.
+ *
+ * Directory conventions:
+ *   docs/prd/          — PM output (versioned PRD files)
+ *   docs/architecture/ — Engineer design docs
+ *   docs/qa/           — QA test plans and reports
+ *   docs/review/       — Reviewer reports
+ *   src/               — Engineer implementation
+ *   tests/             — QA test code
+ */
+
+import type { WorkspaceAgentConfig } from './types';
+
+type PresetTemplate = Omit<WorkspaceAgentConfig, 'id'>;
+
+export const AGENT_PRESETS: Record<string, PresetTemplate> = {
+  pm: {
+    label: 'PM',
+    icon: '📋',
+    role: `You are a Product Manager. Your output goes in docs/prd/ directory.
+
+Rules:
+- Each PRD version is a separate file: docs/prd/v1.0-initial.md, docs/prd/v1.1-add-history.md, etc.
+- NEVER overwrite existing PRD files. Always create a new version file.
+- The version number should reflect the scope: patch (v1.0.1) for small fixes, minor (v1.1) for new features, major (v2.0) for major changes.
+- Each file should reference which requirements it addresses.
+- Do NOT write code or modify source files.`,
+    backend: 'cli',
+    agentId: 'claude',
+    dependsOn: [],
+    workDir: './',
+    outputs: ['docs/prd/'],
+    steps: [
+      { id: 'analyze', label: 'Analyze Requirements', prompt: 'Read the new requirements from upstream input. Then list all existing files in docs/prd/ to understand what versions exist. Identify what is NEW vs what was already covered in previous PRD versions.' },
+      { id: 'write-prd', label: 'Write PRD', prompt: 'Create a NEW versioned PRD file in docs/prd/ (e.g., docs/prd/v1.1-feature-name.md). Include: version, date, referenced requirements, goals, user stories, acceptance criteria, and technical constraints. Do NOT overwrite any existing PRD file.' },
+      { id: 'review', label: 'Self-Review', prompt: 'Review the PRD you just wrote. Ensure version number is correct, all new requirements are covered, and it does not duplicate content from previous versions. Fix any issues.' },
+    ],
+  },
+
+  engineer: {
+    label: 'Engineer',
+    icon: '🔨',
+    role: `You are a Senior Software Engineer. Your design docs go in docs/architecture/ directory.
+
+Rules:
+- Read ALL files in docs/prd/ to understand the full requirements history.
+- Read ALL files in docs/architecture/ to understand previous design decisions.
+- Only implement NEW or CHANGED requirements. Check your memory and existing code first.
+- Architecture docs are versioned: docs/architecture/v1.0-initial.md, etc.
+- Do NOT rewrite existing working code unless the PRD explicitly requires changes.`,
+    backend: 'cli',
+    agentId: 'claude',
+    dependsOn: [],
+    workDir: './',
+    outputs: ['src/', 'docs/architecture/'],
+    steps: [
+      { id: 'design', label: 'Architecture Design', prompt: 'Read all files in docs/prd/ (latest first) and docs/architecture/. Identify what needs to be designed or changed. Create a new architecture doc in docs/architecture/ (e.g., docs/architecture/v1.1-add-history.md) describing the changes. Do NOT overwrite existing architecture files.' },
+      { id: 'implement', label: 'Implementation', prompt: 'Implement the features based on your architecture design. Only modify files that need to change. Write clean, well-documented code.' },
+      { id: 'self-test', label: 'Self-Test', prompt: 'Review your implementation. Run any existing tests. Fix any obvious issues.' },
+    ],
+  },
+
+  qa: {
+    label: 'QA',
+    icon: '🧪',
+    role: `You are a QA Engineer. Your test plans and reports go in docs/qa/ directory.
+
+Rules:
+- Read docs/prd/ to understand requirements (focus on latest version).
+- Read docs/qa/ to see what was already tested. Skip tests that already passed for unchanged features.
+- Test plans are versioned: docs/qa/test-plan-v1.1.md
+- Test reports are versioned: docs/qa/test-report-v1.1.md
+- Test code goes in tests/ directory.
+- Do NOT fix bugs — only report them clearly in your test report.
+
+Communication rules:
+- Only send [SEND:...] messages for BLOCKING issues that prevent the product from working.
+- Minor issues, suggestions, and style feedback go in your test report ONLY — do NOT send messages for these.
+- Send at most 1-2 messages total. Consolidate multiple issues into one message.
+- Never send messages during Test Planning or Write Tests steps — only in Execute Tests.`,
+    backend: 'cli',
+    agentId: 'claude',
+    dependsOn: [],
+    workDir: './',
+    outputs: ['tests/', 'docs/qa/'],
+    steps: [
+      { id: 'plan', label: 'Test Planning', prompt: 'Read the latest PRD in docs/prd/ and existing test plans in docs/qa/. Write a NEW test plan file covering only the NEW/CHANGED features.' },
+      { id: 'write-tests', label: 'Write Tests', prompt: 'Implement test cases in tests/ directory based on your test plan. Add new tests, do not rewrite existing passing tests. Do NOT send any messages to other agents in this step.' },
+      { id: 'execute', label: 'Execute Tests', prompt: 'Run all tests. Write a test report documenting results. Only if you find BLOCKING bugs (app crashes, data loss, security holes), send ONE consolidated message: [SEND:Engineer:fix_request] followed by a brief list of blocking issues. Minor issues go in the report only.' },
+    ],
+  },
+
+  reviewer: {
+    label: 'Reviewer',
+    icon: '🔍',
+    role: `You are a Code Reviewer. Your review reports go in docs/review/ directory.
+
+Rules:
+- Read docs/prd/ (latest) to understand what should have been implemented.
+- Read docs/architecture/ (latest) to understand design decisions.
+- Review ONLY recent code changes, not the entire codebase.
+- Review reports are versioned: docs/review/review-v1.1.md
+- Do NOT modify code directly.
+
+Communication rules:
+- Only send [SEND:...] messages for CRITICAL issues: security vulnerabilities, data corruption, or completely broken functionality.
+- All other feedback (code style, performance suggestions, minor issues) goes in your review report ONLY.
+- Send at most 1 message to Engineer and 1 to PM. Consolidate issues.
+- If no critical issues found, do NOT send any messages.`,
+    backend: 'cli',
+    agentId: 'claude',
+    dependsOn: [],
+    workDir: './',
+    outputs: ['docs/review/'],
+    steps: [
+      { id: 'review-code', label: 'Code Review', prompt: 'Read the latest PRD and architecture docs. Review recent source code changes. Check for: code quality, security issues, performance, naming conventions, and adherence to PRD.' },
+      { id: 'report', label: 'Write Report', prompt: 'Write a review report with all findings. Only if you found CRITICAL issues (security, data corruption, broken core functionality), send ONE consolidated message: [SEND:Engineer:fix_request] with the critical issues. For requirement problems: [SEND:PM:fix_request]. If no critical issues, do NOT send any messages.' },
+    ],
+  },
+};
+
+/**
+ * Create a full dev pipeline: Input → PM → Engineer → QA → Reviewer
+ * With proper dependsOn wiring, versioned output directories, and incremental prompts.
+ */
+export function createDevPipeline(): WorkspaceAgentConfig[] {
+  const ts = Date.now();
+  const inputId = `input-${ts}`;
+  const pmId = `pm-${ts}`;
+  const engId = `engineer-${ts}`;
+  const qaId = `qa-${ts}`;
+  const revId = `reviewer-${ts}`;
+
+  return [
+    {
+      id: inputId, label: 'Requirements', icon: '📝',
+      type: 'input', content: '', entries: [],
+      role: '', backend: 'cli', dependsOn: [], outputs: [], steps: [],
+    },
+    {
+      ...AGENT_PRESETS.pm, id: pmId, dependsOn: [inputId],
+    },
+    {
+      ...AGENT_PRESETS.engineer, id: engId, dependsOn: [pmId],
+    },
+    {
+      ...AGENT_PRESETS.qa, id: qaId, dependsOn: [engId],
+    },
+    {
+      ...AGENT_PRESETS.reviewer, id: revId, dependsOn: [engId, qaId],
+    },
+  ];
+}
+
+/** @deprecated Use createDevPipeline instead */
+export function createDeliveryPipeline(): WorkspaceAgentConfig[] {
+  return createDevPipeline();
+}
+
+/** Get a preset by key, assigning a unique ID */
+export function createFromPreset(key: string, overrides?: Partial<WorkspaceAgentConfig>): WorkspaceAgentConfig {
+  const preset = AGENT_PRESETS[key];
+  if (!preset) throw new Error(`Unknown preset: ${key}`);
+  return {
+    ...preset,
+    id: `${key}-${Date.now()}`,
+    ...overrides,
+  };
+}

package/lib/workspace/skill-installer.ts

@@ -0,0 +1,188 @@
+/**
+ * Forge Skills Auto-Installer — installs forge skills into user's ~/.claude/skills/
+ * so they are available across all projects and sessions.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const _filename = typeof __filename !== 'undefined' ? __filename : fileURLToPath(import.meta.url);
+const _dirname = typeof __dirname !== 'undefined' ? __dirname : dirname(_filename);
+const FORGE_SKILLS_DIR = join(_dirname, '..', 'forge-skills');
+
+/**
+ * Install forge workspace skills into user's ~/.claude/skills/.
+ * Skills use env vars ($FORGE_PORT, $FORGE_WORKSPACE_ID, $FORGE_AGENT_ID)
+ * so they work across all projects without per-project configuration.
+ */
+export function installForgeSkills(
+  projectPath: string,
+  workspaceId: string,
+  agentId: string,
+  forgePort = 8403,
+): { installed: string[] } {
+  const skillsDir = join(homedir(), '.claude', 'skills');
+  mkdirSync(skillsDir, { recursive: true });
+
+  const installed: string[] = [];
+
+  // Read all skill templates
+  let sourceDir = FORGE_SKILLS_DIR;
+  if (!existsSync(sourceDir)) {
+    sourceDir = join(process.cwd(), 'lib', 'forge-skills');
+  }
+  if (!existsSync(sourceDir)) return { installed };
+
+  const files = readdirSync(sourceDir).filter(f => f.endsWith('.md'));
+
+  for (const file of files) {
+    const content = readFileSync(join(sourceDir, file), 'utf-8');
+    // Claude Code expects skills as directories with SKILL.md inside
+    const skillName = file.replace('.md', '');
+    const skillDir = join(skillsDir, skillName);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, 'SKILL.md'), content, 'utf-8');
+    installed.push(skillName);
+  }
+
+  // Clean up old flat .md files (from previous install format)
+  for (const file of files) {
+    const flatFile = join(skillsDir, file);
+    if (existsSync(flatFile)) {
+      try { require('node:fs').unlinkSync(flatFile); } catch {}
+    }
+  }
+
+  // Ensure settings allow forge curl commands (check both global and project)
+  ensureForgePermissions(join(homedir(), '.claude'));
+  // Also fix project-level deny rules that might block forge curl
+  const projectClaudeDir = join(projectPath, '.claude');
+  if (existsSync(join(projectClaudeDir, 'settings.json'))) {
+    ensureForgePermissions(projectClaudeDir);
+  }
+
+  return { installed };
+}
+
+/**
+ * Ensure project's .claude/settings.json allows forge skill curl commands.
+ * Removes curl deny rules that block forge, adds allow rule if needed.
+ */
+function ensureForgePermissions(projectPath: string): void {
+  const settingsFile = join(projectPath, '.claude', 'settings.json');
+  const FORGE_CURL_ALLOW = 'Bash(curl*localhost*/smith*)';
+
+  try {
+    let settings: any = {};
+    if (existsSync(settingsFile)) {
+      settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+    }
+
+    if (!settings.permissions) settings.permissions = {};
+    if (!settings.permissions.allow) settings.permissions.allow = [];
+    if (!settings.permissions.deny) settings.permissions.deny = [];
+
+    let changed = false;
+
+    // Remove deny rules that block curl to localhost (forge skills)
+    const denyBefore = settings.permissions.deny.length;
+    settings.permissions.deny = settings.permissions.deny.filter((rule: string) => {
+      // Remove broad curl denies that would block forge
+      if (/^Bash\(curl[:\s*]/.test(rule)) return false;
+      return true;
+    });
+    if (settings.permissions.deny.length !== denyBefore) changed = true;
+
+    // Add forge curl allow if not present
+    const hasForgeAllow = settings.permissions.allow.some((rule: string) =>
+      rule.includes('localhost') && rule.includes('smith')
+    );
+    if (!hasForgeAllow) {
+      settings.permissions.allow.push(FORGE_CURL_ALLOW);
+      changed = true;
+    }
+
+    if (changed) {
+      mkdirSync(join(projectPath, '.claude'), { recursive: true });
+      writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+      console.log('[skills] Updated .claude/settings.json: allowed forge curl commands');
+    }
+  } catch (err: any) {
+    console.error('[skills] Failed to update .claude/settings.json:', err.message);
+  }
+}
+
+/**
+ * Apply agent profile config to project's .claude/settings.json.
+ * Sets env vars and model from the profile so interactive claude uses the right config.
+ */
+export function applyProfileToProject(
+  projectPath: string,
+  profile: { env?: Record<string, string>; model?: string },
+): void {
+  if (!profile.env && !profile.model) return;
+
+  const settingsFile = join(projectPath, '.claude', 'settings.json');
+  try {
+    let settings: any = {};
+    if (existsSync(settingsFile)) {
+      settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+    }
+
+    let changed = false;
+
+    // Set env vars from profile
+    if (profile.env && Object.keys(profile.env).length > 0) {
+      if (!settings.env) settings.env = {};
+      for (const [key, value] of Object.entries(profile.env)) {
+        if (settings.env[key] !== value) {
+          settings.env[key] = value;
+          changed = true;
+        }
+      }
+    }
+
+    // Set model from profile
+    if (profile.model) {
+      if (settings.model !== profile.model) {
+        settings.model = profile.model;
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      mkdirSync(join(projectPath, '.claude'), { recursive: true });
+      writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+      console.log(`[skills] Applied profile config to .claude/settings.json (model=${profile.model || 'default'}, env=${Object.keys(profile.env || {}).length} vars)`);
+    }
+  } catch (err: any) {
+    console.error('[skills] Failed to apply profile config:', err.message);
+  }
+}
+
+/**
+ * Check if forge skills are already installed for this agent.
+ */
+export function hasForgeSkills(projectPath: string): boolean {
+  const globalDir = join(homedir(), '.claude', 'skills');
+  return existsSync(join(globalDir, 'forge-workspace-sync', 'SKILL.md'));
+}
+
+/**
+ * Remove forge skills from a project.
+ */
+export function removeForgeSkills(projectPath: string): void {
+  const skillsDir = join(homedir(), '.claude', 'skills');
+  if (!existsSync(skillsDir)) return;
+
+  const forgeSkills = readdirSync(skillsDir).filter(f => f.startsWith('forge-'));
+  for (const name of forgeSkills) {
+    const p = join(skillsDir, name);
+    try {
+      const { rmSync } = require('node:fs');
+      rmSync(p, { recursive: true, force: true });
+    } catch {}
+  }
+}