@soleri/cli 9.8.0 → 9.10.0

package/src/commands/agent.ts

@@ -28,11 +28,26 @@ import {
   generateInjectClaudeMd,
   generateSkills,
 } from '@soleri/forge/lib';
-import { composeClaudeMd, getEngineRulesContent } from '@soleri/forge/lib';
-import type { AgentConfig } from '@soleri/forge/lib';
+import { composeClaudeMd, getModularEngineRules, AgentYamlSchema } from '@soleri/forge/lib';
+import type { AgentConfig, EngineFeature } from '@soleri/forge/lib';
 import { detectAgent } from '../utils/agent-context.js';
 import { installClaude } from './install.js';
 
+/**
+ * Read engine.features from agent.yaml at the given agent path.
+ * Returns undefined if not specified (= include all modules).
+ */
+function readEngineFeatures(agentPath: string): EngineFeature[] | undefined {
+  try {
+    const yamlPath = join(agentPath, 'agent.yaml');
+    if (!existsSync(yamlPath)) return undefined;
+    const parsed = AgentYamlSchema.parse(parseYaml(readFileSync(yamlPath, 'utf-8')));
+    return parsed.engine?.features as EngineFeature[] | undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export function registerAgent(program: Command): void {
   const agent = program.command('agent').description('Agent lifecycle management');
 
@@ -263,7 +278,11 @@ export function registerAgent(program: Command): void {
 
         // 2. Regenerate _engine.md
         mkdirSync(join(ctx.agentPath, 'instructions'), { recursive: true });
-        writeFileSync(enginePath, getEngineRulesContent(), 'utf-8');
+        writeFileSync(
+          enginePath,
+          getModularEngineRules(readEngineFeatures(ctx.agentPath)),
+          'utf-8',
+        );
         p.log.success(`Regenerated ${enginePath}`);
 
         // 3. Recompose CLAUDE.md
@@ -407,7 +426,11 @@ export function registerAgent(program: Command): void {
 
         // 2. Regenerate _engine.md from latest shared-rules
         mkdirSync(join(ctx.agentPath, 'instructions'), { recursive: true });
-        writeFileSync(enginePath, getEngineRulesContent(), 'utf-8');
+        writeFileSync(
+          enginePath,
+          getModularEngineRules(readEngineFeatures(ctx.agentPath)),
+          'utf-8',
+        );
         p.log.success(`Regenerated ${enginePath}`);
 
         // 3. Recompose CLAUDE.md from agent.yaml + instructions + workflows + skills

package/src/commands/create.ts

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { accessSync, constants as fsConstants, readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
@@ -97,7 +97,16 @@ export function registerCreate(program: Command): void {
               p.log.error(`Config file not found: ${configPath}`);
               process.exit(1);
             }
-            const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let raw: any;
+            try {
+              raw = JSON.parse(readFileSync(configPath, 'utf-8'));
+            } catch {
+              p.log.error(
+                `Failed to parse ${configPath}. The file may be corrupted. Delete it and try again.`,
+              );
+              process.exit(1);
+            }
             const parsed = AgentConfigSchema.safeParse(raw);
             if (!parsed.success) {
               p.log.error(`Invalid config: ${parsed.error.message}`);
@@ -175,6 +184,15 @@ export function registerCreate(program: Command): void {
             };
 
             const outputDir = opts?.dir ? resolve(opts.dir) : (config.outputDir ?? process.cwd());
+
+            // Preflight: check output directory is writable
+            try {
+              accessSync(outputDir, fsConstants.W_OK);
+            } catch {
+              p.log.error(`Cannot write to ${outputDir} — check permissions`);
+              process.exit(1);
+            }
+
             const nonInteractive = !!(opts?.yes || opts?.config);
 
             if (!nonInteractive) {

package/src/commands/dev.ts

@@ -35,7 +35,14 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
   regenerateClaudeMd(agentPath);
 
   // Start the engine server
-  const engineBin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
+  let engineBin: string;
+  try {
+    engineBin = require.resolve('@soleri/core/dist/engine/bin/soleri-engine.js');
+  } catch {
+    p.log.error('Engine not found. Run: npm install @soleri/core');
+    process.exit(1);
+  }
+
   const engine = spawn('node', [engineBin, '--agent', join(agentPath, 'agent.yaml')], {
     stdio: ['pipe', 'inherit', 'inherit'],
     env: { ...process.env },
@@ -72,8 +79,11 @@ function runFileTreeDev(agentPath: string, agentId: string): void {
           regenerateClaudeMd(agentPath);
         }, 200);
       });
-    } catch {
-      // Directory may not exist yet — that's OK
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes('ENOENT')) {
+        p.log.warn(`File watch stopped: ${msg}. Restart soleri dev if changes stop updating.`);
+      }
     }
   }
 

package/src/commands/install.ts

@@ -1,7 +1,14 @@
 import type { Command } from 'commander';
 import { createRequire } from 'node:module';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import {
+  accessSync,
+  constants as fsConstants,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import * as p from '@clack/prompts';
 import { detectAgent } from '../utils/agent-context.js';
@@ -11,6 +18,9 @@ const SOLERI_HOME = process.env.SOLERI_HOME ?? join(homedir(), '.soleri');
 
 type Target = 'claude' | 'codex' | 'opencode' | 'both' | 'all';
 
+/** Normalize a file path to forward slashes (POSIX) for cross-platform config files. */
+export const toPosix = (p: string): string => p.replace(/\\/g, '/');
+
 /**
  * Resolve the absolute path to the soleri-engine binary.
  * Falls back to `npx @soleri/engine` if resolution fails (e.g. not installed globally).
@@ -28,17 +38,18 @@ function resolveEngineBin(): { command: string; bin: string } {
 /** MCP server entry for file-tree agents (resolved engine path, no npx) */
 function fileTreeMcpEntry(agentDir: string): Record<string, unknown> {
   const engine = resolveEngineBin();
+  const agentYaml = toPosix(join(agentDir, 'agent.yaml'));
   if (engine.command === 'node') {
     return {
       type: 'stdio',
       command: 'node',
-      args: [engine.bin, '--agent', join(agentDir, 'agent.yaml')],
+      args: [toPosix(engine.bin), '--agent', agentYaml],
     };
   }
   return {
     type: 'stdio',
     command: 'npx',
-    args: ['@soleri/engine', '--agent', join(agentDir, 'agent.yaml')],
+    args: ['@soleri/engine', '--agent', agentYaml],
   };
 }
 
@@ -47,13 +58,36 @@ function legacyMcpEntry(agentDir: string): Record<string, unknown> {
   return {
     type: 'stdio',
     command: 'node',
-    args: [join(agentDir, 'dist', 'index.js')],
+    args: [toPosix(join(agentDir, 'dist', 'index.js'))],
     env: {},
   };
 }
 
+/**
+ * Check if a file path is writable. If the file exists, checks write permission on the file.
+ * If the file does not exist, checks write permission on the parent directory.
+ */
+function checkWritable(filePath: string): boolean {
+  try {
+    if (existsSync(filePath)) {
+      accessSync(filePath, fsConstants.W_OK);
+    } else {
+      accessSync(dirname(filePath), fsConstants.W_OK);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export function installClaude(agentId: string, agentDir: string, isFileTree: boolean): void {
   const configPath = join(homedir(), '.claude.json');
+
+  if (!checkWritable(configPath)) {
+    p.log.error(`Cannot write to ${configPath} — check file permissions`);
+    process.exit(1);
+  }
+
   let config: Record<string, unknown> = {};
 
   if (existsSync(configPath)) {
@@ -73,7 +107,12 @@ export function installClaude(agentId: string, agentDir: string, isFileTree: boo
     ? fileTreeMcpEntry(agentDir)
     : legacyMcpEntry(agentDir);
 
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  try {
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  } catch {
+    p.log.error(`Cannot write to ${configPath}. Check file permissions.`);
+    process.exit(1);
+  }
   p.log.success(`Registered ${agentId} in ~/.claude.json`);
 }
 
@@ -82,7 +121,12 @@ function installCodex(agentId: string, agentDir: string, isFileTree: boolean): v
   const configPath = join(codexDir, 'config.toml');
 
   if (!existsSync(codexDir)) {
-    mkdirSync(codexDir, { recursive: true });
+    try {
+      mkdirSync(codexDir, { recursive: true });
+    } catch {
+      p.log.error(`Cannot create directory ${codexDir}. Check permissions.`);
+      process.exit(1);
+    }
   }
 
   let content = '';
@@ -97,21 +141,27 @@ function installCodex(agentId: string, agentDir: string, isFileTree: boolean): v
 
   let section: string;
   if (isFileTree) {
-    const agentYamlPath = join(agentDir, 'agent.yaml');
+    const agentYamlPath = toPosix(join(agentDir, 'agent.yaml'));
     const engine = resolveEngineBin();
     if (engine.command === 'node') {
-      section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${engine.bin}", "--agent", "${agentYamlPath}"]\n`;
+      const bin = toPosix(engine.bin);
+      section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${bin}", "--agent", "${agentYamlPath}"]\n`;
     } else {
       section = `\n\n${sectionHeader}\ncommand = "npx"\nargs = ["@soleri/engine", "--agent", "${agentYamlPath}"]\n`;
     }
   } else {
-    const entryPoint = join(agentDir, 'dist', 'index.js');
+    const entryPoint = toPosix(join(agentDir, 'dist', 'index.js'));
     section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${entryPoint}"]\n`;
   }
 
   content = content + section;
 
-  writeFileSync(configPath, content.trim() + '\n', 'utf-8');
+  try {
+    writeFileSync(configPath, content.trim() + '\n', 'utf-8');
+  } catch {
+    p.log.error(`Cannot write to ${configPath}. Check file permissions.`);
+    process.exit(1);
+  }
   p.log.success(`Registered ${agentId} in ~/.codex/config.toml`);
 }
 
@@ -122,7 +172,12 @@ function installOpencode(agentId: string, agentDir: string, isFileTree: boolean)
   const configPath = join(configDir, 'opencode.json');
 
   if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
+    try {
+      mkdirSync(configDir, { recursive: true });
+    } catch {
+      p.log.error(`Cannot create directory ${configDir}. Check permissions.`);
+      process.exit(1);
+    }
   }
 
   let config: Record<string, unknown> = {};
@@ -132,7 +187,10 @@ function installOpencode(agentId: string, agentDir: string, isFileTree: boolean)
       const stripped = raw.replace(/^\s*\/\/.*$/gm, '');
       config = JSON.parse(stripped);
     } catch {
-      config = {};
+      p.log.error(
+        `Failed to parse ${configPath}. The file may be corrupted. Delete it and try again.`,
+      );
+      process.exit(1);
     }
   }
 
@@ -143,21 +201,27 @@ function installOpencode(agentId: string, agentDir: string, isFileTree: boolean)
   const servers = config.mcp as Record<string, unknown>;
   if (isFileTree) {
     const engine = resolveEngineBin();
+    const agentYaml = toPosix(join(agentDir, 'agent.yaml'));
     servers[agentId] = {
       type: 'local',
       command:
         engine.command === 'node'
-          ? ['node', engine.bin, '--agent', join(agentDir, 'agent.yaml')]
-          : ['npx', '-y', '@soleri/engine', '--agent', join(agentDir, 'agent.yaml')],
+          ? ['node', toPosix(engine.bin), '--agent', agentYaml]
+          : ['npx', '-y', '@soleri/engine', '--agent', agentYaml],
     };
   } else {
     servers[agentId] = {
       type: 'local',
-      command: ['node', join(agentDir, 'dist', 'index.js')],
+      command: ['node', toPosix(join(agentDir, 'dist', 'index.js'))],
     };
   }
 
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  try {
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  } catch {
+    p.log.error(`Cannot write to ${configPath}. Check file permissions.`);
+    process.exit(1);
+  }
   p.log.success(`Registered ${agentId} in ~/.config/opencode/opencode.json`);
 }
 
@@ -172,7 +236,10 @@ function escapeRegExp(s: string): string {
 function installLauncher(agentId: string, agentDir: string): void {
   // Launcher scripts to /usr/local/bin are Unix-only
   if (process.platform === 'win32') {
-    p.log.info('Launcher scripts are not supported on Windows — skipping');
+    p.log.info('Launcher scripts are not supported on Windows.');
+    p.log.info(
+      `On Windows, run your agent with: npx @soleri/cli dev --agent "${toPosix(agentDir)}"`,
+    );
     return;
   }
 
@@ -182,7 +249,7 @@ function installLauncher(agentId: string, agentDir: string): void {
     '#!/bin/bash',
     `# ${agentId} — Soleri second brain launcher`,
     `# Type "${agentId}" from any directory to open Claude Code with this agent`,
-    `exec claude --mcp-config ${join(agentDir, '.mcp.json')}`,
+    `exec claude --mcp-config ${toPosix(join(agentDir, '.mcp.json'))}`,
     '',
   ].join('\n');
 
@@ -192,7 +259,7 @@ function installLauncher(agentId: string, agentDir: string): void {
   } catch {
     p.log.warn(`Could not create launcher at ${binPath} (may need sudo)`);
     p.log.info(
-      `To create manually: sudo bash -c 'cat > ${binPath} << "EOF"\\n#!/bin/bash\\nexec claude --mcp-config ${join(agentDir, '.mcp.json')}\\nEOF' && chmod +x ${binPath}`,
+      `To create manually: sudo bash -c 'cat > ${binPath} << "EOF"\\n#!/bin/bash\\nexec claude --mcp-config ${toPosix(join(agentDir, '.mcp.json'))}\\nEOF' && chmod +x ${binPath}`,
     );
   }
 }

package/src/commands/vault.ts

@@ -0,0 +1,79 @@
+/**
+ * Vault CLI — export vault entries as browsable markdown files.
+ *
+ * `soleri vault export`                     — export to ./knowledge/vault/
+ * `soleri vault export --path ~/obsidian`   — export to custom directory
+ * `soleri vault export --domain arch`       — filter by domain
+ */
+
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Command } from 'commander';
+import { detectAgent } from '../utils/agent-context.js';
+import * as log from '../utils/logger.js';
+import { SOLERI_HOME } from '@soleri/core';
+
+export function registerVault(program: Command): void {
+  const vault = program.command('vault').description('Vault knowledge management');
+
+  vault
+    .command('export')
+    .description('Export vault entries as browsable markdown files')
+    .option('--path <dir>', 'Output directory (default: ./knowledge/)')
+    .option('--domain <name>', 'Filter by domain')
+    .action(async (opts: { path?: string; domain?: string }) => {
+      const agent = detectAgent();
+      if (!agent) {
+        log.fail('Not in a Soleri agent project', 'Run from an agent directory');
+        process.exit(1);
+      }
+
+      const outputDir = opts.path ? resolve(opts.path) : resolve('knowledge');
+
+      // Find vault DB — check new path first, then legacy
+      const newDbPath = join(SOLERI_HOME, agent.agentId, 'vault.db');
+      const legacyDbPath = join(SOLERI_HOME, '..', `.${agent.agentId}`, 'vault.db');
+      const vaultDbPath = existsSync(newDbPath)
+        ? newDbPath
+        : existsSync(legacyDbPath)
+          ? legacyDbPath
+          : null;
+
+      if (!vaultDbPath) {
+        log.fail('Vault DB not found', 'Run the agent once to initialize its vault database.');
+        process.exit(1);
+      }
+
+      // Dynamic import to avoid loading better-sqlite3 unless needed
+      const { Vault } = await import('@soleri/core');
+      const vaultInstance = new Vault(vaultDbPath);
+
+      try {
+        log.heading('Vault Export');
+
+        if (opts.domain) {
+          const { syncEntryToMarkdown } = await import('@soleri/core');
+          const entries = vaultInstance.list({ limit: 10000, domain: opts.domain });
+          let synced = 0;
+          for (const entry of entries) {
+            await syncEntryToMarkdown(entry, outputDir);
+            synced++;
+          }
+          log.pass(
+            `Exported ${synced} entries from domain "${opts.domain}"`,
+            `${outputDir}/vault/`,
+          );
+        } else {
+          const { syncAllToMarkdown } = await import('@soleri/core');
+          const result = await syncAllToMarkdown(vaultInstance, outputDir);
+          log.pass(
+            `Exported ${result.synced} entries (${result.skipped} unchanged)`,
+            `${outputDir}/vault/`,
+          );
+        }
+      } finally {
+        vaultInstance.close();
+      }
+    });
+}

package/src/hook-packs/rtk/README.md

@@ -0,0 +1,31 @@
+# RTK Hook Pack
+
+Reduces LLM token usage by 60-90% by routing shell commands through [RTK](https://github.com/rtk-ai/rtk), a Rust-based CLI proxy that compresses verbose command output.
+
+## How it works
+
+A PreToolUse hook intercepts Bash commands and rewrites them through RTK:
+
+```
+git status  →  rtk git status  →  "M 3 files" (instead of 15 lines)
+npm test    →  rtk npm test    →  "2 failed" (instead of 200+ lines)
+```
+
+RTK supports 70+ commands across git, JS/TS, Python, Go, Ruby, Docker, and file operations.
+
+## Prerequisites
+
+- [RTK](https://github.com/rtk-ai/rtk) >= 0.23.0 (`brew install rtk-ai/tap/rtk` or `cargo install rtk`)
+- `jq` (usually pre-installed on macOS/Linux)
+
+## Install
+
+```bash
+soleri hooks add-pack rtk
+```
+
+## Uninstall
+
+```bash
+soleri hooks remove-pack rtk
+```

package/src/hook-packs/rtk/manifest.json

@@ -0,0 +1,24 @@
+{
+  "name": "rtk",
+  "version": "1.0.0",
+  "description": "RTK token compression — rewrites shell commands through RTK proxy to reduce LLM token usage by 60-90%",
+  "hooks": [],
+  "scripts": [
+    {
+      "name": "rtk-rewrite",
+      "file": "rtk-rewrite.sh",
+      "targetDir": "hooks"
+    }
+  ],
+  "lifecycleHooks": [
+    {
+      "event": "PreToolUse",
+      "matcher": "Bash",
+      "type": "command",
+      "command": "sh ~/.claude/hooks/rtk-rewrite.sh",
+      "timeout": 10,
+      "statusMessage": "RTK: compressing output..."
+    }
+  ],
+  "scaffoldDefault": false
+}

package/src/hook-packs/rtk/scripts/rtk-rewrite.sh

@@ -0,0 +1,70 @@
+#!/bin/sh
+# RTK Rewrite — PreToolUse command rewriter (Soleri Hook Pack: rtk)
+# Intercepts Bash commands and rewrites them through RTK proxy for token compression.
+# RTK (https://github.com/rtk-ai/rtk) reduces LLM token usage by 60-90%.
+# Dependencies: jq, rtk (>= 0.23.0)
+# POSIX sh compatible.
+
+set -eu
+
+# ── Dependency checks ──────────────────────────────────────────────
+
+WARN_FLAG="${HOME}/.soleri/.rtk-warned"
+
+warn_once() {
+  # Warn at most once per day (86400 seconds)
+  if [ -f "$WARN_FLAG" ]; then
+    # Get file mtime — try macOS stat, then Linux stat, fallback to 0
+    FILE_MTIME=0
+    if stat -f %m "$WARN_FLAG" >/dev/null 2>&1; then
+      FILE_MTIME=$(stat -f %m "$WARN_FLAG")
+    elif stat -c %Y "$WARN_FLAG" >/dev/null 2>&1; then
+      FILE_MTIME=$(stat -c %Y "$WARN_FLAG")
+    fi
+    NOW=$(date +%s)
+    WARN_AGE=$(( NOW - FILE_MTIME ))
+    [ "$WARN_AGE" -lt 86400 ] && return
+  fi
+  mkdir -p "$(dirname "$WARN_FLAG")"
+  echo "$1" >&2
+  touch "$WARN_FLAG"
+}
+
+if ! command -v jq >/dev/null 2>&1; then
+  warn_once "[soleri:rtk] jq not found — RTK hook disabled. Install: https://stedolan.github.io/jq/"
+  exit 0
+fi
+
+if ! command -v rtk >/dev/null 2>&1; then
+  warn_once "[soleri:rtk] rtk not found — RTK hook disabled. Install: https://github.com/rtk-ai/rtk"
+  exit 0
+fi
+
+# ── Read stdin JSON ────────────────────────────────────────────────
+
+INPUT=$(cat)
+
+# Extract command from Claude Code PreToolUse JSON
+CMD=$(printf '%s' "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+if [ -z "$CMD" ]; then
+  exit 0
+fi
+
+# ── Rewrite via RTK ────────────────────────────────────────────────
+
+# Ask RTK if it can compress this command.
+# Exit codes: 0 = rewritten, 1 = no match (pass through), 2+ = error
+REWRITTEN=$(rtk rewrite "$CMD" 2>/dev/null) || exit 0
+
+# If RTK returned empty or same command, pass through
+if [ -z "$REWRITTEN" ] || [ "$REWRITTEN" = "$CMD" ]; then
+  exit 0
+fi
+
+# ── Return rewritten command ───────────────────────────────────────
+
+# Build updatedInput from original tool_input with rewritten command
+UPDATED_INPUT=$(printf '%s' "$INPUT" | jq -c --arg cmd "$REWRITTEN" '.tool_input | .command = $cmd')
+
+# Output Claude Code hookSpecificOutput contract
+printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"allow","permissionDecisionReason":"RTK token compression","updatedInput":%s}}' "$UPDATED_INPUT"

package/src/main.ts

@@ -1,5 +1,13 @@
 #!/usr/bin/env node
 
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 18) {
+  console.error(
+    `\n  Soleri requires Node.js 18 or later.\n  You have v${process.versions.node}.\n  Upgrade at https://nodejs.org\n`,
+  );
+  process.exit(1);
+}
+
 import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import { registerCreate } from './commands/create.js';
@@ -21,6 +29,7 @@ import { registerSkills } from './commands/skills.js';
 import { registerAgent } from './commands/agent.js';
 import { registerTelegram } from './commands/telegram.js';
 import { registerStaging } from './commands/staging.js';
+import { registerVault } from './commands/vault.js';
 import { registerYolo } from './commands/yolo.js';
 
 const require = createRequire(import.meta.url);
@@ -83,5 +92,6 @@ registerSkills(program);
 registerAgent(program);
 registerTelegram(program);
 registerStaging(program);
+registerVault(program);
 registerYolo(program);
 program.parse();

package/src/utils/format-paths.ts

@@ -1,41 +0,0 @@
-/**
- * Format-aware path resolution for filetree vs typescript agents.
- */
-import { join } from 'node:path';
-
-export interface FormatPaths {
-  knowledgeDir: string;
-  extensionsDir: string;
-  facadesDir: string;
-  agentConfigFile: string;
-  entryPoint: string;
-}
-
-export function getFormatPaths(ctx: {
-  format: 'filetree' | 'typescript';
-  agentPath: string;
-}): FormatPaths {
-  const { format, agentPath } = ctx;
-
-  if (format === 'filetree') {
-    return {
-      knowledgeDir: join(agentPath, 'knowledge'),
-      extensionsDir: join(agentPath, 'extensions'),
-      facadesDir: '',
-      agentConfigFile: join(agentPath, 'agent.yaml'),
-      entryPoint: join(agentPath, 'agent.yaml'),
-    };
-  }
-
-  return {
-    knowledgeDir: join(agentPath, 'src', 'intelligence', 'data'),
-    extensionsDir: join(agentPath, 'src', 'extensions'),
-    facadesDir: join(agentPath, 'src', 'facades'),
-    agentConfigFile: join(agentPath, 'package.json'),
-    entryPoint: join(agentPath, 'src', 'index.ts'),
-  };
-}
-
-export function isFileTree(ctx: { format: string }): boolean {
-  return ctx.format === 'filetree';
-}