@codename_inc/spectre 3.7.0 → 4.0.0

package/src/lib/install.js

@@ -1,11 +1,8 @@
 import fs from 'fs';
 import path from 'path';
-import { pathToFileURL } from 'url';
 import {
-  codexCommandSkillName,
-  listCodexWorkflowCommands,
   listSpectreAgents,
-  listSpectreCommands,
+  listSpectreSkills,
   SHARED_SKILLS,
   repoMetadata
 } from './constants.js';
@@ -15,7 +12,6 @@ import {
   removeSpectreHooksConfigured,
   syncProjectSkillsConfigured
 } from './config.js';
-import { codexSharedSkillContent } from './knowledge.js';
 import { installProjectFiles, uninstallProjectFiles } from './project.js';
 import {
   codexPromptsDir,
@@ -25,11 +21,7 @@ import {
   repoRoot,
   runtimeAgentsDir,
   runtimeHooksDir,
-  runtimeSourceAgentsDir,
-  runtimeSourceCommandsDir,
-  runtimeSourceRoot,
   runtimeToolsDir,
-  spectrePluginRoot
 } from './paths.js';
 
 function writeFile(targetPath, content, mode) {
@@ -40,220 +32,106 @@ function writeFile(targetPath, content, mode) {
   }
 }
 
-function readMarkdown(filePath) {
-  return fs.readFileSync(filePath, 'utf8');
+function generatedCodexRoot() {
+  return path.join(repoRoot(), 'plugins', 'spectre-codex');
 }
 
-function escapeTomlMultilineString(value) {
-  return value.replaceAll('"""', '\\"""');
+function generatedCodexSkillsDir() {
+  return path.join(generatedCodexRoot(), 'skills');
 }
 
-function escapeTomlBasicString(value) {
-  return JSON.stringify(value);
+function generatedCodexAgentsDir() {
+  return path.join(generatedCodexRoot(), 'agents');
 }
 
-function escapeYamlDoubleQuotedString(value) {
-  return JSON.stringify(value);
+function generatedCodexHooksDir() {
+  return path.join(generatedCodexRoot(), 'hooks');
 }
 
-function splitFrontmatter(content) {
-  if (!content.startsWith('---\n')) {
-    return { frontmatter: '', body: content.trim() };
-  }
+function generatedCodexHooksConfigPath() {
+  return path.join(generatedCodexHooksDir(), 'hooks.json');
+}
 
-  const end = content.indexOf('\n---\n', 4);
-  if (end === -1) {
-    return { frontmatter: '', body: content.trim() };
+function generatedCodexHooksConfig() {
+  const hooksPath = generatedCodexHooksConfigPath();
+  if (!fs.existsSync(hooksPath)) {
+    throw new Error(`Missing generated Codex hooks config: ${hooksPath}. Run npm run sync-codex first.`);
   }
 
-  return {
-    frontmatter: content.slice(4, end).trim(),
-    body: content.slice(end + 5).trim()
-  };
-}
-
-function frontmatterValue(frontmatter, key) {
-  const match = frontmatter.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
-  return match ? match[1].trim().replace(/^["']|["']$/g, '') : '';
+  const parsed = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !parsed.hooks) {
+    throw new Error(`Malformed generated Codex hooks config: ${hooksPath}`);
+  }
+  return parsed.hooks;
 }
 
-function commandLabel(commandName) {
-  return `spectre-${commandName}`;
-}
+function listGeneratedCodexSkills({ required = false } = {}) {
+  const skillsDir = generatedCodexSkillsDir();
+  if (!fs.existsSync(skillsDir)) {
+    if (required) {
+      throw new Error(`Missing generated Codex skills directory: ${skillsDir}. Run npm run sync-codex first.`);
+    }
+    return [];
+  }
 
-function commandSourceLabel(commandName) {
-  return `/spectre:${commandName}`;
+  return fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && fs.existsSync(path.join(skillsDir, entry.name, 'SKILL.md')))
+    .map(entry => entry.name)
+    .sort();
 }
 
-function copySourceAssets() {
-  const pluginRoot = spectrePluginRoot();
-  ensureDir(runtimeSourceRoot());
-  fs.cpSync(path.join(pluginRoot, 'commands'), runtimeSourceCommandsDir(), { recursive: true });
-  fs.cpSync(path.join(pluginRoot, 'agents'), runtimeSourceAgentsDir(), { recursive: true });
+function managedCodexSkillNames({ requireGenerated = false } = {}) {
+  return Array.from(new Set([
+    ...SHARED_SKILLS,
+    ...listSpectreSkills(),
+    ...listGeneratedCodexSkills({ required: requireGenerated })
+  ])).sort();
 }
 
-function sharedSkillContent(skillName) {
-  const codexSkill = codexSharedSkillContent(skillName);
-  if (codexSkill) {
-    return codexSkill;
+function replaceDirectory(sourceDir, targetDir) {
+  if (!fs.existsSync(sourceDir)) {
+    throw new Error(`Missing generated Codex asset directory: ${sourceDir}. Run npm run sync-codex first.`);
   }
 
-  if (skillName === 'spectre-guide') {
-    return `---
-name: ${escapeYamlDoubleQuotedString('spectre-guide')}
-description: ${escapeYamlDoubleQuotedString('Use when suggesting the next Spectre workflow skill or explaining the Spectre workflow.')}
----
-
-# Spectre Guide
-
-Core path: \`spectre-scope\` -> \`spectre-plan\` -> \`spectre-execute\` -> \`spectre-clean\` -> \`spectre-test\` -> \`spectre-rebase\` -> \`spectre-evaluate\`.
+  fs.rmSync(targetDir, { recursive: true, force: true });
+  ensureDir(path.dirname(targetDir));
+  fs.cpSync(sourceDir, targetDir, { recursive: true });
+}
 
-Use \`spectre-handoff\` to save continuity and \`spectre-forget\` to clear it.
-`;
+function removeLegacyPrefixedSkillDirs() {
+  const skillsRoot = codexSkillsDir();
+  if (!fs.existsSync(skillsRoot)) {
+    return;
   }
 
-  if (skillName === 'spectre-learn') {
-    return `---
-name: ${escapeYamlDoubleQuotedString('spectre-learn')}
-description: ${escapeYamlDoubleQuotedString('Use when capturing durable project knowledge into Codex-native skills.')}
----
-
-# Spectre Learn
-
-Store learned project knowledge under \`.agents/skills/{category}-{slug}/SKILL.md\`.
-
-Each new learning should:
-- include YAML frontmatter with \`name\` and \`description\`
-- focus on actionable project knowledge
-- be updated when behavior changes
-`;
+  for (const entry of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith('spectre-')) {
+      continue;
+    }
+    const bareName = entry.name.slice('spectre-'.length);
+    if (managedCodexSkillNames().includes(bareName)) {
+      fs.rmSync(path.join(skillsRoot, entry.name), { recursive: true, force: true });
+    }
   }
-
-  return `---
-name: ${escapeYamlDoubleQuotedString('spectre-tdd')}
-description: ${escapeYamlDoubleQuotedString("Use when following Spectre's TDD-first execution style.")}
----
-
-# Spectre TDD
-
-Default cycle:
-1. Write or identify the failing behavior.
-2. Add the smallest test that proves the behavior.
-3. Implement the smallest code change that makes the test pass.
-4. Refactor only after the test passes.
-`;
 }
 
-function installSharedSkills() {
+function installGeneratedCodexSkills() {
+  const sourceRoot = generatedCodexSkillsDir();
   const skillsRoot = codexSkillsDir();
   ensureDir(skillsRoot);
-  for (const skillName of SHARED_SKILLS) {
-    const skillPath = path.join(skillsRoot, skillName, 'SKILL.md');
-    writeFile(skillPath, sharedSkillContent(skillName));
-  }
-}
 
-function workflowPostStep(commandName, runtimeRoot) {
-  const refreshCommand = `node "${path.join(runtimeRoot, 'tools', 'refresh-project-context.mjs')}" --project-root "$PWD"`;
-  const syncCommand = `node "${path.join(runtimeRoot, 'tools', 'sync-session-override.mjs')}" --project-root "$PWD" --source handoff`;
-  const clearCommand = `node "${path.join(runtimeRoot, 'tools', 'sync-session-override.mjs')}" --project-root "$PWD" --clear`;
-
-  if (commandName === 'learn') {
-    return `After creating or updating project skills, run:\n\n\`\`\`bash\n${refreshCommand}\n\`\`\`\n`;
-  }
+  removeLegacyPrefixedSkillDirs();
 
-  if (commandName === 'handoff') {
-    return `After saving the handoff, run:\n\n\`\`\`bash\n${syncCommand}\n\`\`\`\n`;
+  for (const skillName of managedCodexSkillNames({ requireGenerated: true })) {
+    const skillDir = path.join(skillsRoot, skillName);
+    if (fs.existsSync(skillDir)) {
+      fs.rmSync(skillDir, { recursive: true, force: true });
+    }
   }
 
-  if (commandName === 'forget') {
-    return `After clearing session memory, run:\n\n\`\`\`bash\n${clearCommand}\n\`\`\`\n`;
+  for (const skillName of listGeneratedCodexSkills({ required: true })) {
+    fs.cpSync(path.join(sourceRoot, skillName), path.join(skillsRoot, skillName), { recursive: true });
   }
-
-  return 'No extra runtime step is required for this command.\n';
-}
-
-function workflowBody(sourceContent) {
-  return sourceContent
-    .replace(/(?:<|&lt;)ARGUMENTS(?:>|&gt;)\s*\$ARGUMENTS\s*(?:<\/|&lt;\/)ARGUMENTS(?:>|&gt;)/g, 'Treat the current user request as the input for this workflow.')
-    .replace(/\$ARGUMENTS/g, 'the current user request')
-    .replaceAll('/spectre:', 'spectre-');
-}
-
-function workflowSkill(commandName, runtimeRoot) {
-  const commandSource = readMarkdown(path.join(runtimeSourceCommandsDir(), `${commandName}.md`)).trim();
-  const { frontmatter, body } = splitFrontmatter(commandSource);
-  const description = frontmatterValue(frontmatter, 'description') || `Use when running the Spectre ${commandName} workflow.`;
-
-  return `---
-name: ${escapeYamlDoubleQuotedString(codexCommandSkillName(commandName))}
-description: ${escapeYamlDoubleQuotedString(description)}
-user-invocable: true
----
-
-# ${commandLabel(commandName)}
-
-Use when the user explicitly wants the Spectre \`${commandName}\` workflow, or when another Spectre workflow delegates to it.
-
-This is the Codex skill replacement for the deprecated custom prompt ${commandSourceLabel(commandName)}.
-
-## Input Handling
-
-Treat the current user request as the input arguments for this workflow.
-
-## Required setup
-
-1. Read \`AGENTS.md\` if present.
-2. Read \`.spectre/manifest.json\` if present.
-3. Read project skills under \`.agents/skills/\` when their descriptions match the task.
-4. Prefer the installed Spectre subagents when the workflow dispatches specialized roles.
-
-## Codex translation layer
-
-- Treat both \`@spectre:name\` and \`@name\` as the installed Spectre Codex subagent for that role.
-- If multi-agent support is available, spawn the relevant subagent(s). If not, execute the same work sequentially yourself and preserve the same artifacts, checks, and completion reports.
-- Treat \`Skill(name)\` or skill-tool instructions as: load the named Codex skill from \`.agents/skills/{name}/SKILL.md\` or \`$CODEX_HOME/skills/{name}/SKILL.md\` before continuing.
-- Treat nested \`/spectre:other\` references as instructions to execute the installed \`spectre-other\` workflow skill immediately, not as a suggestion to stop and ask the user.
-- Ignore Claude plugin, marketplace, model, and tool declarations. Preserve Spectre artifact paths and handoff JSON shapes.
-
-## Canonical workflow
-
-${workflowBody(body)}
-
-## Command-specific post step
-
-${workflowPostStep(commandName, runtimeRoot)}
-`;
-}
-
-function codexAgentBody(agentName, sourceContent) {
-  const { frontmatter, body } = splitFrontmatter(sourceContent);
-  const description = frontmatterValue(frontmatter, 'description') || `${agentName} specialist`;
-  const instructions = `You are the Codex port of Spectre's \`${agentName}\` subagent.
-
-## Role
-
-${description}
-
-## Operating rules
-
-- Stay inside this role's scope.
-- Preserve Spectre file locations and document contracts.
-- If the parent command provided task, scope, or handoff docs, read them before acting.
-- Return concrete findings or completion output that the parent workflow can consume directly.
-
-## Canonical instructions
-
-${body}`;
-  return {
-    description,
-    content: `name = ${escapeTomlBasicString(agentName)}
-description = ${escapeTomlBasicString(description)}
-developer_instructions = """
-${escapeTomlMultilineString(instructions)}
-"""
-`
-  };
 }
 
 function agentNicknames(agentName) {
@@ -265,23 +143,28 @@ function agentNicknames(agentName) {
   ]));
 }
 
+function tomlStringField(content, fieldName) {
+  const match = content.match(new RegExp(`^${fieldName}\\s*=\\s*(".*")$`, 'm'));
+  return match ? JSON.parse(match[1]) : '';
+}
+
 function installAgentConfigs() {
   const configs = [];
-  ensureDir(runtimeAgentsDir());
-  for (const entry of fs.readdirSync(runtimeAgentsDir(), { withFileTypes: true })) {
-    if (entry.isFile() && entry.name.endsWith('.md')) {
-      fs.unlinkSync(path.join(runtimeAgentsDir(), entry.name));
+  replaceDirectory(generatedCodexAgentsDir(), runtimeAgentsDir());
+
+  for (const entry of fs.readdirSync(runtimeAgentsDir(), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isFile() || !entry.name.endsWith('.toml')) {
+      continue;
     }
-  }
-  for (const agentName of listSpectreAgents()) {
-    const sourcePath = path.join(runtimeSourceAgentsDir(), `${agentName}.md`);
-    const agent = codexAgentBody(agentName, readMarkdown(sourcePath));
-    const configFile = path.join(runtimeAgentsDir(), `${agentName}.toml`);
-    writeFile(configFile, agent.content);
+
+    const configFile = path.join(runtimeAgentsDir(), entry.name);
+    const content = fs.readFileSync(configFile, 'utf8');
+    const agentName = tomlStringField(content, 'name') || path.basename(entry.name, '.toml');
+    const description = tomlStringField(content, 'description') || `${agentName} specialist`;
     configs.push({
       id: agentName.replace(/-/g, '_'),
       name: agentName,
-      description: agent.description,
+      description,
       configFile,
       nicknames: agentNicknames(agentName)
     });
@@ -289,26 +172,13 @@ function installAgentConfigs() {
   return configs;
 }
 
-function installWorkflowSkills() {
-  const runtimeRoot = codexRuntimeRoot();
-  const skillsRoot = codexSkillsDir();
-  ensureDir(skillsRoot);
-
-  for (const commandName of listCodexWorkflowCommands()) {
-    writeFile(
-      path.join(skillsRoot, codexCommandSkillName(commandName), 'SKILL.md'),
-      workflowSkill(commandName, runtimeRoot)
-    );
-  }
-}
-
 function cleanupLegacyPrompts() {
   if (!fs.existsSync(codexPromptsDir())) {
     return;
   }
 
-  for (const commandName of listSpectreCommands()) {
-    for (const fileName of [`spectre:${commandName}.md`, `spectre-${commandName}.md`]) {
+  for (const skillName of listSpectreSkills()) {
+    for (const fileName of [`spectre:${skillName}.md`, `spectre-${skillName}.md`, `${skillName}.md`]) {
       const filePath = path.join(codexPromptsDir(), fileName);
       if (fs.existsSync(filePath)) {
         fs.unlinkSync(filePath);
@@ -317,105 +187,28 @@ function cleanupLegacyPrompts() {
   }
 }
 
-function sessionStartHook() {
-  const projectModuleUrl = pathToFileURL(path.join(repoRoot(), 'src', 'lib', 'project.js')).href;
-  return `#!/usr/bin/env node
-import fs from 'fs';
-import path from 'path';
-
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    let input = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', chunk => { input += chunk; });
-    process.stdin.on('end', () => resolve(input));
-    process.stdin.on('error', reject);
-  });
-}
-
-const input = await readStdin();
-let payload = {};
-if (input) {
-  try {
-    payload = JSON.parse(input);
-  } catch {
-    process.exit(0);
-  }
-}
-const cwd = payload.cwd || process.cwd();
-const manifestPath = path.join(cwd, '.spectre', 'manifest.json');
-
-if (!fs.existsSync(manifestPath)) {
-  process.exit(0);
-}
-
-const { buildSessionStartOutput } = await import(${JSON.stringify(projectModuleUrl)});
-const output = buildSessionStartOutput(cwd, payload);
-if (!output) {
-  process.exit(0);
-}
-
-process.stdout.write(JSON.stringify(output) + '\\n');
-`;
-}
-
 function refreshProjectTool() {
-  const configModuleUrl = pathToFileURL(path.join(repoRoot(), 'src', 'lib', 'config.js')).href;
-  const projectModuleUrl = pathToFileURL(path.join(repoRoot(), 'src', 'lib', 'project.js')).href;
   return `#!/usr/bin/env node
-const projectRootIndex = process.argv.indexOf('--project-root');
-if (projectRootIndex === -1 || !process.argv[projectRootIndex + 1]) {
-  throw new Error('Missing required --project-root argument');
-}
-
-const projectRoot = process.argv[projectRootIndex + 1];
-const { syncProjectSkillsConfigured } = await import(${JSON.stringify(configModuleUrl)});
-const { syncKnowledgeOverride } = await import(${JSON.stringify(projectModuleUrl)});
-syncProjectSkillsConfigured(projectRoot);
-syncKnowledgeOverride(projectRoot);
-process.stdout.write('Synced Spectre project skills and knowledge context.\\n');
+process.stderr.write('refresh-project-context is no longer installed as a package-cache wrapper. Run "npx @codename_inc/spectre update codex --scope project --project-dir <path>" to refresh SPECTRE assets.\\n');
+process.exit(1);
 `;
 }
 
 function syncSessionOverrideTool() {
-  const projectModuleUrl = pathToFileURL(path.join(repoRoot(), 'src', 'lib', 'project.js')).href;
   return `#!/usr/bin/env node
-const projectRootIndex = process.argv.indexOf('--project-root');
-if (projectRootIndex === -1 || !process.argv[projectRootIndex + 1]) {
-  throw new Error('Missing required --project-root argument');
-}
-
-const projectRoot = process.argv[projectRootIndex + 1];
-const clear = process.argv.includes('--clear');
-const sourceIndex = process.argv.indexOf('--source');
-const source = sourceIndex === -1 ? 'manual' : (process.argv[sourceIndex + 1] || 'manual');
-
-const { clearSessionOverride, syncKnowledgeOverride, syncSessionOverride } = await import(${JSON.stringify(projectModuleUrl)});
-
-if (clear) {
-  clearSessionOverride(projectRoot);
-  const knowledge = syncKnowledgeOverride(projectRoot);
-  process.stdout.write(\`Cleared SPECTRE session context. Knowledge status: \${knowledge.knowledgeStatus}.\\n\`);
-} else {
-  const session = syncSessionOverride(projectRoot, { source });
-  const knowledge = syncKnowledgeOverride(projectRoot);
-  if (session) {
-    process.stdout.write(\`Synced SPECTRE context from \${session.handoffPath}. Knowledge status: \${knowledge.knowledgeStatus}.\\n\`);
-  } else {
-    process.stdout.write(\`No active handoff found; refreshed knowledge context. Knowledge status: \${knowledge.knowledgeStatus}.\\n\`);
-  }
-}
+process.stderr.write('sync-session-override is no longer installed as a package-cache wrapper. Session context is refreshed by SPECTRE SessionStart hooks.\\n');
+process.exit(1);
 `;
 }
 
 function installRuntimeScripts() {
-  const hooksDir = runtimeHooksDir();
   const toolsDir = runtimeToolsDir();
-  ensureDir(hooksDir);
   ensureDir(toolsDir);
+  replaceDirectory(generatedCodexHooksDir(), runtimeHooksDir());
 
   for (const stalePath of [
-    path.join(hooksDir, 'pre-session-start.mjs'),
+    path.join(runtimeHooksDir(), 'pre-session-start.mjs'),
+    path.join(runtimeHooksDir(), 'session-start.mjs'),
     path.join(toolsDir, 'forget-project-context.mjs')
   ]) {
     if (fs.existsSync(stalePath)) {
@@ -423,7 +216,6 @@ function installRuntimeScripts() {
     }
   }
 
-  writeFile(path.join(hooksDir, 'session-start.mjs'), sessionStartHook(), 0o755);
   writeFile(path.join(toolsDir, 'refresh-project-context.mjs'), refreshProjectTool(), 0o755);
   writeFile(path.join(toolsDir, 'sync-session-override.mjs'), syncSessionOverrideTool(), 0o755);
 }
@@ -431,13 +223,11 @@ function installRuntimeScripts() {
 export function installCodex({ scope, projectDir }) {
   const runtimeRoot = codexRuntimeRoot();
   ensureDir(runtimeRoot);
-  copySourceAssets();
   installRuntimeScripts();
   cleanupLegacyPrompts();
-  installSharedSkills();
-  installWorkflowSkills();
+  installGeneratedCodexSkills();
   const agents = installAgentConfigs();
-  ensureSpectreHooksConfigured(runtimeRoot, agents);
+  ensureSpectreHooksConfigured(runtimeRoot, agents, generatedCodexHooksConfig());
 
   if (scope === 'project') {
     installProjectFiles(projectDir, scope);
@@ -459,15 +249,10 @@ export function uninstallCodex({ scope, projectDir }) {
     fs.rmSync(codexRuntimeRoot(), { recursive: true, force: true });
   }
 
-  for (const skillName of SHARED_SKILLS) {
-    const skillDir = path.join(codexSkillsDir(), skillName);
-    if (fs.existsSync(skillDir)) {
-      fs.rmSync(skillDir, { recursive: true, force: true });
-    }
-  }
+  removeLegacyPrefixedSkillDirs();
 
-  for (const commandName of listCodexWorkflowCommands()) {
-    const skillDir = path.join(codexSkillsDir(), codexCommandSkillName(commandName));
+  for (const skillName of managedCodexSkillNames()) {
+    const skillDir = path.join(codexSkillsDir(), skillName);
     if (fs.existsSync(skillDir)) {
       fs.rmSync(skillDir, { recursive: true, force: true });
     }

package/src/lib/knowledge.js

@@ -20,7 +20,7 @@ function rewriteProjectSkillPaths(content) {
 }
 
 function rewriteCodexCommandRefs(content) {
-  return content.replaceAll('/spectre:', 'spectre-');
+  return content.replaceAll('/spectre:', '');
 }
 
 function markUserInvocable(content, value = true) {
@@ -70,7 +70,7 @@ function pluginSkillPath(skillName) {
 }
 
 function recallTemplatePath() {
-  return path.join(spectrePluginRoot(), 'skills', 'spectre-learn', 'references', 'recall-template.md');
+  return path.join(spectrePluginRoot(), 'skills', 'learn', 'references', 'recall-template.md');
 }
 
 function pluginSkillContent(skillName) {
@@ -78,11 +78,11 @@ function pluginSkillContent(skillName) {
 }
 
 export function codexSharedSkillContent(skillName) {
-  if (skillName === 'spectre-apply') {
+  if (skillName === 'apply') {
     return `${normalizeSkillMarkdown(rewriteCodexCommandRefs(rewriteProjectSkillPaths(pluginSkillContent(skillName))))}\n`;
   }
 
-  if (skillName === 'spectre-learn') {
+  if (skillName === 'learn') {
     return `${normalizeSkillMarkdown(markUserInvocable(rewriteCodexCommandRefs(codexPathConvention(codexLearnIntro(rewriteProjectSkillPaths(pluginSkillContent(skillName)))))))}\n`;
   }
 
@@ -121,34 +121,6 @@ export function readKnowledgeRegistry(projectDir) {
   };
 }
 
-function knowledgeRegistrySection(registryContent, entryCount) {
-  if (entryCount > 0) {
-    return [
-      '## Registry',
-      '',
-      '**Format**: `skill-name|category|triggers|description`',
-      '',
-      '```',
-      registryContent,
-      '```',
-      '',
-      'Each entry corresponds to a skill that can be loaded via `Skill({skill-name})`',
-      '',
-      '**Categories:** feature, gotchas, patterns, decisions, procedures, integration, performance, testing, ux, strategy'
-    ].join('\n');
-  }
-
-  return [
-    '## Registry',
-    '',
-    'No knowledge has been captured for this project yet. The behavioral rules in this document still apply.',
-    '',
-    'To capture knowledge from this session, use `spectre-learn` after completing significant work.',
-    '',
-    '**Categories:** feature, gotchas, patterns, decisions, procedures, integration, performance, testing, ux, strategy'
-  ].join('\n');
-}
-
 export function generateRecallSkillContent(projectDir) {
   const { registryContent } = readKnowledgeRegistry(projectDir);
   const template = fs.readFileSync(recallTemplatePath(), 'utf8');
@@ -169,10 +141,8 @@ export function ensureKnowledgeFiles(projectDir) {
 
 export function buildKnowledgeOverrideBody(projectDir) {
   ensureKnowledgeFiles(projectDir);
-  const { registryContent, entryCount } = readKnowledgeRegistry(projectDir);
-  const applyContent = stripFrontmatter(rewriteCodexCommandRefs(rewriteProjectSkillPaths(pluginSkillContent('spectre-apply')))).replace(
-    /## Registry Location[\s\S]*?(?=## Workflow)/,
-    `${knowledgeRegistrySection(registryContent, entryCount)}\n\n`
+  const applyContent = stripFrontmatter(
+    rewriteCodexCommandRefs(rewriteProjectSkillPaths(pluginSkillContent('apply')))
   );
 
   return normalizeSkillMarkdown(applyContent);
@@ -210,7 +180,7 @@ export function knowledgeStatusMessage(projectDir) {
   const { entryCount } = readKnowledgeRegistry(projectDir);
 
   if (entryCount === 0) {
-    return '👻 spectre: ready — capture knowledge with spectre-learn';
+    return '👻 spectre: ready — capture knowledge with /spectre:learn';
   }
 
   return `👻 spectre: ${entryCount} knowledge skills available`;

package/src/lib/paths.js

@@ -42,18 +42,6 @@ export function codexRuntimeRoot() {
   return path.join(resolveCodexHome(), 'spectre');
 }
 
-export function runtimeSourceRoot() {
-  return path.join(codexRuntimeRoot(), 'source');
-}
-
-export function runtimeSourceCommandsDir() {
-  return path.join(runtimeSourceRoot(), 'commands');
-}
-
-export function runtimeSourceAgentsDir() {
-  return path.join(runtimeSourceRoot(), 'agents');
-}
-
 export function runtimeAgentsDir() {
   return path.join(codexRuntimeRoot(), 'agents');
 }