@codename_inc/spectre 3.7.0 → 5.0.0

package/src/lib/config.js

@@ -279,57 +279,103 @@ function writeHooksConfig(hooksPath, config) {
   fs.writeFileSync(hooksPath, `${JSON.stringify(nextConfig, null, 2)}\n`);
 }
 
-function spectreSessionStartCommand(runtimeRoot) {
-  return `node ${shellQuote(path.join(runtimeRoot, 'hooks', 'session-start.mjs'))}`;
-}
-
-function isSpectreSessionStartHook(hook) {
+function isSpectreHook(hook) {
   return hook
     && typeof hook === 'object'
     && hook.type === 'command'
     && typeof hook.command === 'string'
-    && hook.command.includes('spectre/hooks/session-start.mjs');
+    && (
+      hook.command.includes('spectre/hooks/session-start.mjs')
+      || hook.command.includes('spectre/hooks/scripts/')
+    );
 }
 
-function upsertSpectreSessionStartHook(runtimeRoot) {
-  const { hooksPath, config } = readHooksConfig();
-  const hooks = { ...(config.hooks ?? {}) };
-  const groups = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
-  const nextGroups = [];
+function materializeHookCommand(command, runtimeRoot) {
+  return command
+    .replaceAll('${CODEX_HOME}/spectre', runtimeRoot)
+    .replaceAll('${CODEX_HOME}\\spectre', runtimeRoot)
+    .replace(/^node\s+(.+)$/, (_match, scriptPath) => `node ${shellQuote(scriptPath)}`);
+}
+
+function materializeGeneratedHooks(generatedHooks, runtimeRoot) {
+  const materialized = {};
 
-  for (const group of groups) {
-    if (!group || typeof group !== 'object' || Array.isArray(group)) {
-      nextGroups.push(group);
+  for (const [eventName, groups] of Object.entries(generatedHooks ?? {})) {
+    if (!Array.isArray(groups)) {
       continue;
     }
 
-    const hookList = Array.isArray(group.hooks) ? group.hooks.filter(hook => !isSpectreSessionStartHook(hook)) : [];
-    if (hookList.length > 0) {
-      nextGroups.push({
+    materialized[eventName] = groups.map(group => {
+      if (!group || typeof group !== 'object' || Array.isArray(group)) {
+        return group;
+      }
+
+      const hookList = Array.isArray(group.hooks) ? group.hooks.map(hook => {
+        if (!hook || typeof hook !== 'object' || Array.isArray(hook)) {
+          return hook;
+        }
+        if (hook.type !== 'command' || typeof hook.command !== 'string') {
+          return hook;
+        }
+
+        return {
+          ...hook,
+          command: materializeHookCommand(hook.command, runtimeRoot)
+        };
+      }) : group.hooks;
+
+      return {
         ...group,
         hooks: hookList
-      });
-    }
+      };
+    });
   }
 
-  nextGroups.push({
-    hooks: [
-      {
-        type: 'command',
-        command: spectreSessionStartCommand(runtimeRoot),
-        statusMessage: 'Spectre: loading session context'
+  return materialized;
+}
+
+function upsertSpectreHooks(runtimeRoot, generatedHooks) {
+  const { hooksPath, config } = readHooksConfig();
+  const hooks = { ...(config.hooks ?? {}) };
+  const materializedHooks = materializeGeneratedHooks(generatedHooks, runtimeRoot);
+
+  for (const eventName of new Set([...Object.keys(hooks), ...Object.keys(materializedHooks)])) {
+    const groups = Array.isArray(hooks[eventName]) ? hooks[eventName] : [];
+    const nextGroups = [];
+
+    for (const group of groups) {
+      if (!group || typeof group !== 'object' || Array.isArray(group)) {
+        nextGroups.push(group);
+        continue;
       }
-    ]
-  });
 
-  hooks.SessionStart = nextGroups;
+      const hookList = Array.isArray(group.hooks) ? group.hooks.filter(hook => !isSpectreHook(hook)) : [];
+      if (hookList.length > 0) {
+        nextGroups.push({
+          ...group,
+          hooks: hookList
+        });
+      }
+    }
+
+    if (Array.isArray(materializedHooks[eventName])) {
+      nextGroups.push(...materializedHooks[eventName]);
+    }
+
+    if (nextGroups.length > 0) {
+      hooks[eventName] = nextGroups;
+    } else {
+      delete hooks[eventName];
+    }
+  }
+
   writeHooksConfig(hooksPath, {
     ...config,
     hooks
   });
 }
 
-function removeSpectreSessionStartHook() {
+function removeSpectreHooks() {
   const hooksPath = codexHooksConfigPath();
   if (!fs.existsSync(hooksPath)) {
     return false;
@@ -337,35 +383,40 @@ function removeSpectreSessionStartHook() {
 
   const { config } = readHooksConfig();
   const hooks = { ...(config.hooks ?? {}) };
-  const groups = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
   let removed = false;
-  const nextGroups = [];
 
-  for (const group of groups) {
-    if (!group || typeof group !== 'object' || Array.isArray(group)) {
-      nextGroups.push(group);
+  for (const [eventName, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) {
       continue;
     }
 
-    const originalHooks = Array.isArray(group.hooks) ? group.hooks : [];
-    const filteredHooks = originalHooks.filter(hook => {
-      const shouldRemove = isSpectreSessionStartHook(hook);
-      removed ||= shouldRemove;
-      return !shouldRemove;
-    });
+    const nextGroups = [];
+    for (const group of groups) {
+      if (!group || typeof group !== 'object' || Array.isArray(group)) {
+        nextGroups.push(group);
+        continue;
+      }
 
-    if (filteredHooks.length > 0) {
-      nextGroups.push({
-        ...group,
-        hooks: filteredHooks
+      const originalHooks = Array.isArray(group.hooks) ? group.hooks : [];
+      const filteredHooks = originalHooks.filter(hook => {
+        const shouldRemove = isSpectreHook(hook);
+        removed ||= shouldRemove;
+        return !shouldRemove;
       });
+
+      if (filteredHooks.length > 0) {
+        nextGroups.push({
+          ...group,
+          hooks: filteredHooks
+        });
+      }
     }
-  }
 
-  if (nextGroups.length > 0) {
-    hooks.SessionStart = nextGroups;
-  } else {
-    delete hooks.SessionStart;
+    if (nextGroups.length > 0) {
+      hooks[eventName] = nextGroups;
+    } else {
+      delete hooks[eventName];
+    }
   }
 
   writeHooksConfig(hooksPath, {
@@ -448,7 +499,7 @@ export function removeProjectSkillsConfigured(projectDir) {
   writeConfig(configPath, content);
 }
 
-export function ensureSpectreHooksConfigured(runtimeRoot, agents) {
+export function ensureSpectreHooksConfigured(runtimeRoot, agents, generatedHooks = {}) {
   const { configPath, content: initialContent } = readConfig();
   let content = initialContent;
 
@@ -457,7 +508,8 @@ export function ensureSpectreHooksConfigured(runtimeRoot, agents) {
   content = removeScalarKey(content, 'hooks', 'session_start');
   content = removeEntryFromArrayLine(content, 'hooks.blocking', 'pre_session_start', preSessionEntry);
   content = upsertRootScalarKey(content, 'suppress_unstable_features_warning', 'true');
-  content = upsertScalarKey(content, 'features', 'codex_hooks', 'true');
+  content = removeScalarKey(content, 'features', 'codex_hooks');
+  content = upsertScalarKey(content, 'features', 'hooks', 'true');
   content = upsertScalarKey(content, 'features', 'skills', 'true');
   content = upsertScalarKey(content, 'features', 'multi_agent', 'true');
   content = removeEmptyTable(content, 'hooks');
@@ -479,7 +531,7 @@ export function ensureSpectreHooksConfigured(runtimeRoot, agents) {
   }
 
   writeConfig(configPath, content);
-  upsertSpectreSessionStartHook(runtimeRoot);
+  upsertSpectreHooks(runtimeRoot, generatedHooks);
 }
 
 export function removeSpectreHooksConfigured(runtimeRoot, agents) {
@@ -491,7 +543,7 @@ export function removeSpectreHooksConfigured(runtimeRoot, agents) {
   let content = fs.readFileSync(configPath, 'utf8');
   const preSessionEntry = `{ command = ["node", "${escapeTomlString(path.join(runtimeRoot, 'hooks', 'pre-session-start.mjs'))}"] }`;
 
-  const removedSessionStartHook = removeSpectreSessionStartHook();
+  const removedSpectreHooks = removeSpectreHooks();
 
   content = removeScalarKey(content, 'hooks', 'session_start');
   content = removeEntryFromArrayLine(content, 'hooks.blocking', 'pre_session_start', preSessionEntry);
@@ -502,7 +554,8 @@ export function removeSpectreHooksConfigured(runtimeRoot, agents) {
     content = removeTable(content, `agents.spectre_${agent.id}`);
   }
 
-  if (removedSessionStartHook && !hasRemainingHookDefinitions()) {
+  if (removedSpectreHooks && !hasRemainingHookDefinitions()) {
+    content = removeScalarKey(content, 'features', 'hooks');
     content = removeScalarKey(content, 'features', 'codex_hooks');
   }
 

package/src/lib/constants.js

@@ -12,28 +12,14 @@ export const SESSION_OVERRIDE_END = '<!-- spectre-session:end -->';
 export const KNOWLEDGE_OVERRIDE_START = '<!-- spectre-knowledge:start -->';
 export const KNOWLEDGE_OVERRIDE_END = '<!-- spectre-knowledge:end -->';
 
-export function listSpectreCommands() {
-  const commandsDir = path.join(spectrePluginRoot(), 'commands');
-  return fs.readdirSync(commandsDir)
-    .filter(name => name.endsWith('.md'))
-    .map(name => path.basename(name, '.md'))
+export function listSpectreSkills() {
+  const skillsDir = path.join(spectrePluginRoot(), 'skills');
+  return fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && fs.existsSync(path.join(skillsDir, entry.name, 'SKILL.md')))
+    .map(entry => entry.name)
     .sort();
 }
 
-export function codexCommandSkillName(commandName) {
-  if (commandName === 'learn') {
-    return 'spectre-learn';
-  }
-  if (commandName === 'recall') {
-    return 'spectre-recall';
-  }
-  return `spectre-${commandName}`;
-}
-
-export function listCodexWorkflowCommands() {
-  return listSpectreCommands().filter(commandName => !['learn', 'recall'].includes(commandName));
-}
-
 export function listSpectreAgents() {
   const agentsDir = path.join(spectrePluginRoot(), 'agents');
   return fs.readdirSync(agentsDir)
@@ -43,10 +29,18 @@ export function listSpectreAgents() {
 }
 
 export const SHARED_SKILLS = [
-  'spectre-apply',
-  'spectre-guide',
-  'spectre-learn',
-  'spectre-tdd'
+  'apply',
+  'guide',
+  'learn',
+  'tdd'
+];
+
+export const WORKFLOW_PROBE_SKILLS = [
+  'scope',
+  'plan',
+  'execute',
+  'clean',
+  'test'
 ];
 
 export function repoMetadata() {

package/src/lib/doctor.js

@@ -2,18 +2,17 @@ import fs from 'fs';
 import path from 'path';
 import { execFileSync } from 'child_process';
 import {
-  codexCommandSkillName,
-  listCodexWorkflowCommands,
   listSpectreAgents,
-  listSpectreCommands,
-  MIN_CODEX_VERSION
+  listSpectreSkills,
+  MIN_CODEX_VERSION,
+  SHARED_SKILLS,
+  WORKFLOW_PROBE_SKILLS
 } from './constants.js';
 import {
   codexConfigPath,
   codexHooksConfigPath,
   codexRuntimeRoot,
   codexSkillsDir,
-  projectPaths,
   resolveCodexHome
 } from './paths.js';
 
@@ -55,7 +54,10 @@ function sessionStartHookConfigured() {
       Array.isArray(group?.hooks) && group.hooks.some(hook =>
         hook?.type === 'command'
         && typeof hook.command === 'string'
-        && hook.command.includes('spectre/hooks/session-start.mjs')
+        && (
+          hook.command.includes('spectre/hooks/session-start.mjs')
+          || hook.command.includes('spectre/hooks/scripts/load-knowledge.mjs')
+        )
       )
     );
 
@@ -68,12 +70,7 @@ function sessionStartHookConfigured() {
   }
 }
 
-function commandSkillPath(projectDir, commandName) {
-  const skillName = codexCommandSkillName(commandName);
-  if (skillName === 'spectre-recall') {
-    return projectPaths(projectDir).recallSkillPath;
-  }
-
+function skillPath(skillName) {
   return path.join(codexSkillsDir(), skillName, 'SKILL.md');
 }
 
@@ -98,7 +95,7 @@ export function runDoctor({ verifyHooks = false, json = false, projectDir = proc
     hooks: {
       verifyRequested: verifyHooks,
       sessionStartConfigured: false,
-      codexHooksEnabled: false,
+      hooksFeatureEnabled: false,
       hiddenContextInjection: 'unconfigured',
       hooksConfigPath: codexHooksConfigPath(),
       hooksConfigPresent: fs.existsSync(codexHooksConfigPath())
@@ -114,12 +111,12 @@ export function runDoctor({ verifyHooks = false, json = false, projectDir = proc
 
   if (fs.existsSync(codexConfigPath())) {
     const config = fs.readFileSync(codexConfigPath(), 'utf8');
-    result.hooks.codexHooksEnabled = config.includes('codex_hooks = true');
+    result.hooks.hooksFeatureEnabled = /^hooks\s*=\s*true\s*$/m.test(config);
     result.hooks.sessionStartConfigured = hookConfigStatus.configured;
     if (hookConfigStatus.error) {
       result.hooks.configError = hookConfigStatus.error;
     }
-    if (result.hooks.sessionStartConfigured && result.hooks.codexHooksEnabled) {
+    if (result.hooks.sessionStartConfigured && result.hooks.hooksFeatureEnabled) {
       result.hooks.hiddenContextInjection = 'agents_override_managed_block';
     } else if (result.hooks.sessionStartConfigured) {
       result.hooks.hiddenContextInjection = 'configured_but_feature_disabled';
@@ -130,13 +127,13 @@ export function runDoctor({ verifyHooks = false, json = false, projectDir = proc
     result.capabilities.multiAgentEnabled = config.includes('multi_agent = true');
   }
 
-  const commandSkillFiles = listSpectreCommands().map(name => commandSkillPath(projectDir, name));
-  result.capabilities.workflowSkillsInstalled = listCodexWorkflowCommands()
-    .some(name => fs.existsSync(path.join(codexSkillsDir(), codexCommandSkillName(name), 'SKILL.md')));
-  result.capabilities.exactWorkflowSkillsInstalled = commandSkillFiles.every(filePath => fs.existsSync(filePath));
+  const expectedSkillFiles = listSpectreSkills().map(name => skillPath(name));
+  result.capabilities.workflowSkillsInstalled = WORKFLOW_PROBE_SKILLS
+    .some(name => fs.existsSync(skillPath(name)));
+  result.capabilities.exactWorkflowSkillsInstalled = expectedSkillFiles.every(filePath => fs.existsSync(filePath));
 
-  result.capabilities.sharedSkillsInstalled = ['spectre-apply', 'spectre-guide', 'spectre-learn', 'spectre-tdd']
-    .every(skill => fs.existsSync(path.join(codexSkillsDir(), skill, 'SKILL.md')));
+  result.capabilities.sharedSkillsInstalled = SHARED_SKILLS
+    .every(skill => fs.existsSync(skillPath(skill)));
 
   if (verifyHooks) {
     result.hooks.manualVerification = 'Use an interactive Codex session to verify SessionStart context injection. `codex exec` is not treated as authoritative for this hook lifecycle.';
@@ -154,7 +151,7 @@ export function runDoctor({ verifyHooks = false, json = false, projectDir = proc
   process.stdout.write(`Runtime present: ${result.installed.runtimeDir ? 'yes' : 'no'}\n`);
   process.stdout.write(`session_start hook configured: ${result.hooks.sessionStartConfigured ? 'yes' : 'no'}\n`);
   process.stdout.write(`hooks.json present: ${result.hooks.hooksConfigPresent ? 'yes' : 'no'}\n`);
-  process.stdout.write(`Experimental codex_hooks enabled: ${result.hooks.codexHooksEnabled ? 'yes' : 'no'}\n`);
+  process.stdout.write(`Hooks feature enabled: ${result.hooks.hooksFeatureEnabled ? 'yes' : 'no'}\n`);
   process.stdout.write(`Hidden context injection: ${result.hooks.hiddenContextInjection}\n`);
   if (result.hooks.configError) {
     process.stdout.write(`Hook config error: ${result.hooks.configError}\n`);