@codename_inc/spectre 3.7.0 → 5.0.0

package/src/pack.test.js

@@ -0,0 +1,87 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+
+function makeTempDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function exec(command, args, options = {}) {
+  return execFileSync(command, args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...options
+  });
+}
+
+function collectFiles(root) {
+  const files = [];
+  if (!fs.existsSync(root)) return files;
+
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  walk(root);
+  return files;
+}
+
+test('packed npm artifact installs Codex assets from generated tree', { concurrency: false }, () => {
+  const repoRoot = path.resolve('.');
+  const packDir = makeTempDir('spectre-pack-');
+  const projectDir = makeTempDir('spectre-pack-install-');
+
+  try {
+    const packOutput = exec('npm', ['pack', '--pack-destination', packDir], { cwd: repoRoot }).trim();
+    const tarball = path.join(packDir, packOutput.split('\n').at(-1));
+
+    exec('npm', ['init', '-y'], { cwd: projectDir });
+    exec('npm', ['install', '--ignore-scripts', '--no-audit', '--no-fund', tarball], { cwd: projectDir });
+    exec('git', ['init', '-b', 'main'], { cwd: projectDir });
+
+    const env = { ...process.env };
+    delete env.CODEX_HOME;
+
+    const unscopedHelp = exec('npx', ['spectre', 'help'], {
+      cwd: projectDir,
+      env
+    });
+    assert.match(unscopedHelp, /spectre install codex/);
+
+    exec('npx', ['@codename_inc/spectre', 'install', 'codex', '--scope', 'project', '--project-dir', projectDir], {
+      cwd: projectDir,
+      env
+    });
+
+    const codexHome = path.join(projectDir, '.codex');
+    assert.ok(fs.existsSync(path.join(codexHome, 'skills', 'plan', 'SKILL.md')));
+    assert.ok(fs.existsSync(path.join(codexHome, 'spectre', 'agents', 'dev.toml')));
+    assert.ok(fs.existsSync(path.join(codexHome, 'spectre', 'hooks', 'scripts', 'load-knowledge.mjs')));
+    assert.ok(!fs.existsSync(path.join(codexHome, 'spectre', 'hooks', 'session-start.mjs')));
+
+    const hooksConfig = JSON.parse(fs.readFileSync(path.join(codexHome, 'hooks.json'), 'utf8'));
+    assert.ok(hooksConfig.hooks.SessionStart.some(group =>
+      Array.isArray(group.hooks) && group.hooks.some(hook => hook.command.includes('spectre/hooks/scripts/load-knowledge.mjs'))
+    ));
+
+    const runtimeFiles = collectFiles(path.join(codexHome, 'spectre'));
+    for (const filePath of runtimeFiles) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      assert.doesNotMatch(content, /file:\/\//, `${filePath} should not contain package-cache file:// imports`);
+      assert.doesNotMatch(content, new RegExp(repoRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')), `${filePath} should not reference the repo checkout`);
+    }
+  } finally {
+    fs.rmSync(packDir, { recursive: true, force: true });
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  }
+});

package/plugins/spectre/commands/learn.md

@@ -1,15 +0,0 @@
----
-description: "\ud83d\udc7b | Capture knowledge for future sessions"
----
-
-# /learn - Capture Project Knowledge
-
-Load the `spectre-learn` skill via `Skill(spectre-learn)` and **execute its workflow step-by-step**.
-
-<CRITICAL>
-This skill supersedes auto-memory. Do NOT write to MEMORY.md or any auto-memory directory. The skill defines the exclusive storage location, format, and registration workflow for captured knowledge.
-
-Treat the skill output as a binding directive, not informational context.
-</CRITICAL>
-
-**Topic**: $ARGUMENTS

package/plugins/spectre/commands/recall.md

@@ -1,5 +0,0 @@
-# /recall - Search Project Knowledge
-
-Load the `spectre-recall` skill and follow its instructions.
-
-**Search query**: $ARGUMENTS

package/plugins/spectre/commands/scope.md

@@ -1,119 +0,0 @@
----
-description: 👻 | Interactively scope a feature or improvement, generating a complete Scope document that clarifies what's IN and OUT -- primary agent
----
-# scope: Interactive Feature Scoping
-
-Collaborative workflow for structuring unstructured thoughts into clear scope boundaries through contextual brainstorming and targeted clarifications. Focuses on user value and scope boundaries before technical considerations. Output: comprehensive scope document with clear boundaries, user value, and key decisions saved to `{OUT_DIR}/concepts/scope.md`.
-
-## ARGUMENTS
-
-<ARGUMENTS> $ARGUMENTS </ARGUMENTS>
-
-## Step 1: Immediate Reply & Gather Context
-
-- **Action** — ImmediateReply: Respond before any tools.
-  - **If** `FROM_KICKOFF=true` → acknowledge kickoff context, read `KICKOFF_DOC`, extract (Core Problem, User Value, Decisions Made, Remaining Ambiguities, Key Code Refs), **SKIP to Step 3**
-  - **Else If** ARGUMENTS empty → probe for context enthusiastically
-  - **Else** → proceed to Step 2
-  - **CRITICAL**: No tool calls except reading kickoff doc when FROM_KICKOFF=true
-
-## Step 2: Interactive Scope Exploration
-
-**SKIP IF FROM_KICKOFF=true**
-
-- **Action** — ExploreScope: Collaborative dialogue focused on boundaries and user experience.
-
-  **CRITICAL**: Focus on WHAT, not HOW. Defer all technical/implementation questions until scope boundaries are finalized. Only ask technical questions if the scope itself is inherently technical (e.g., "migrate database from X to Y").
-
-  **PATTERN**: Lead with a rich initial exploration. In your FIRST response, propose concrete hypotheses AND ask 5-8 questions across multiple dimensions. Give the user a full landscape to react to, not a single thread to follow.
-
-  **FIRST RESPONSE FORMAT**:
-
-  > Here's my initial read on this, plus questions to help us explore the bounds:
-  >
-  > **My hypothesis**: [problem statement, who it affects, proposed IN/OUT]
-  >
-  > **Questions to explore**:
-  > 1. [User problem question]
-  > 2. [UX flow question]
-  > 3. [Boundary edge question]
-  > 4. [Alternative approach question]
-  > 5. [Success criteria question]
-  > 6. [Edge case question]
-  > ...
-  >
-  > Answer any/all that spark thoughts. Skip what's obvious.
-
-  **Question types to include** (aim for 5-8 total, mix from these):
-
-  - **User & Problem**: Who feels this most? What triggers the need? What's the cost of not solving it?
-  - **UX & Feel**: Should this feel fast or thorough? Guided or flexible? What's the ideal flow?
-  - **Boundaries**: What about [adjacent thing]—IN or OUT? If unlimited time, what else? What's essential for v1?
-  - **Alternatives**: I could see this as [A] or [B]. Which direction?
-  - **Edge cases**: What happens when [unusual situation]? Should we handle [error state]?
-  - **Success**: What makes you say "this shipped well"? What's the one thing we can't get wrong?
-
-  **DO NOT ask about**: implementation approach, technical trade-offs, architecture, or integration details until boundaries are confirmed.
-
-- **Action** — IterateBoundaries: After user responds, refine boundaries and ask targeted follow-ups on gaps.
-
-  > **Current Boundaries**: ✅ **IN**: \[list\] ❌ **OUT**: \[list\] ⚠️ **Unsure**: \[edge cases\]
-  >
-  > Any items to move? Add exclusions? Clarify edges? Reply 'looks good' to continue.
-
-- **Wait** — User confirms Scope boundaries are accurate
-
-## Step 3: Generate Targeted Clarifications
-
-- **Action** — DetermineOutputDir:
-
-  - **If** FROM_KICKOFF → use same dir as kickoff doc
-  - **Else** → `OUT_DIR = user_specified || docs/tasks/{branch_name}`
-  - `mkdir -p "$OUT_DIR"`
-
-- **Action** — GenerateTargetedQuestions: Create 3-6 questions based ONLY on remaining scope ambiguities from Step 2 (or kickoff's "Remaining Ambiguities").
-
-  **CRITICAL**: Only ask about unresolved scope ambiguities. Technical questions (architecture, trade-offs, integration) belong in `/spectre:plan`, not here.
-
-- **Action** — SaveClarifications: Create `{OUT_DIR}/clarifications/scope_clarifications_{timestamp}.md`:
-
-  - Header: concept name, confirmed boundaries so far
-  - Questions: Each focused on a scope edge case with `<response></response>` block
-
-- **Action** — PromptUser: "Saved clarifications to `{path}`. Answer in `<response>` blocks. Reply 'Read it' when ready."
-
-- **Wait** — User replies
-
-- **Action** — ReadClarifications: Read file, use responses (proceed with assumptions if empty)
-
-## Step 4: Create Scope Document
-
-- **Action** — CreateScopeDoc: Generate `{OUT_DIR}/concepts/scope.md` (use scoped filename if exists).
-
-  **Priority**: User value and boundaries BEFORE technical details.
-
-  **Sections**: The Problem (pain, impact, current state) → Target Users (primary, secondary, needs) → Success Criteria (outcomes, metrics) → User Experience (journeys, principles, trade-offs) → Scope Boundaries (in/out/maybe/future) → Constraints (platform, perf, a11y, scale) → Integration (touches, avoids, dependencies) → Decisions (from clarifications + rationale) → Risks (UX, scope creep, open questions) → Next Steps (`/spectre:plan` or `/spectre:create_tasks`, complexity S/M/L)
-
-## Step 5: Light Technical Context (Optional)
-
-**Only if scope identifies specific technical/architecture integration points.**
-
-- **Action** — IdentifyTouchpoints: Identify desired areas of research, and dispatch parallel @analyst subagents to research each area. Surface-level only (component names, NOT implementation). List features this interacts with, constraints worth documenting, areas to avoid.
-
-- **Action** — UpdateScopeDoc: Add findings to Integration & Constraints sections if relevant.
-
-## Step 6: Final Review & Next Steps
-
-- **Action** — PresentDocForReview: Show final boundaries and next steps together.
-
-  > **Scope Complete**: `{OUT_DIR}/concepts/scope.md`
-  >
-  > **Final Boundaries**: ✅ **IN**: \[from doc\] ❌ **OUT**: \[from doc\] ⚠️ **Maybe/Future**: \[from doc\]
-  >
-  > Docs saved: `{OUT_DIR}/concepts/scope.md`, `{OUT_DIR}/clarifications/scope_clarifications_{timestamp}.md`
-  >
-  > Reply with any edits, updates, or clarifications — otherwise pick a next step:
-
-- **Action** — RenderFooter: Render Next Steps using `@skill-spectre:spectre-guide` skill.
-
-  > **NOTE**: Do NOT wait for explicit approval. Present next steps immediately inline with the review. User can reply with scope edits OR jump straight into a next step command. If user replies with edits, apply them to the scope doc and re-present.

package/plugins/spectre/commands/ux_spec.md

@@ -1,91 +0,0 @@
----
-description: Define the User Flows and generate a UX Spec - primary agent
----
-# ux_spec: Define Exactly How the Feature Works
-
-Transform product requirements into a definitive behavioral specification. Two stages: align on user flows, then generate detailed spec. Output: `ux.md` ready for implementation.
-
-<ARGUMENTS> $ARGUMENTS </ARGUMENTS>
-
----
-
-# STAGE 1: Flow Discovery & Alignment
-
-**Goal**: Align on HOW the feature works before specifying details.
-
-## Step 1 — Understand the Feature
-
-1. **Read requirements**: `docs/tasks/{branch}/task_summary.md` and `docs/tasks/{branch}/specs/prd.md`
-2. **Research patterns**: Find existing screens/components similar to what we're building, note conventions
-3. **Identify journeys**: List user goals, entry points, and completion states
-
-## Step 2 — Present User Flows
-
-Write each flow as a narrative walkthrough:
-
-**Per flow include**: Goal, Entry point, Journey steps (User sees → User does → System responds), Decision points with branches, Success state, Questions where ambiguity exists
-
-After writing all flows, prompt:
-
-> **User Flows for Review**
->
-> I've mapped {N} flows: {list with one-line summaries}
->
-> Please review: Are these the right flows? Any missing? Do journeys feel right? Answer flagged questions.
->
-> Reply with feedback, or **"Flows approved"** to proceed.
-
-**Wait for approval. If feedback → revise and re-present. If approved → Stage 2.**
-
----
-
-# STAGE 2: Detailed Specification
-
-**Gate**: Only proceed after explicit flow approval.
-
-## Step 3 — Clarify Remaining Details
-
-Review approved flows for gaps: component behaviors, edge cases, state definitions.
-
-If significant gaps, ask 3-5 targeted questions (empty states, error handling, loading, limits). Save to `clarifications/ux_clarifications_{timestamp}.md`, prompt user to read, incorporate answers.
-
-## Step 4 — Write the Specification
-
-Generate complete spec with these sections:
-
-### Required Sections
-
-1. **Overview** — What this feature is, problem it solves, primary user goal (1 paragraph)
-2. **Screens** — Every screen: name, purpose (1 line), navigation relationships
-3. **Flows** — Formalized from Stage 1 with alternate paths (validation fail, cancel, network error)
-4. **Layouts** — Per screen: header/main/footer structure + responsive behavior (desktop >1024, tablet 768-1024, mobile <768)
-5. **Components** — Each interactive element: purpose, location, states (default, hover, active, disabled, loading, error)
-6. **Interactions** — Table format: Element | Action | Result (exhaustive)
-7. **States** — Table format: State | Trigger | Appearance | Available Actions (empty, loading, loaded, error)
-8. **Content** — Exact copy: page titles, buttons, empty states, error messages, confirmation dialogs
-9. **Edge Cases** — Limits/boundaries, null/long data handling, permissions, offline/network failures
-10. **Accessibility** — Tab order, keyboard actions (Enter/Space/Escape), screen reader announcements, focus management
-
-Save to `docs/tasks/{branch}/ux.md`
-
-Prompt:
-
-> **UX Specification Complete**
->
-> Written to `{path}`. Please review: Any behaviors wrong or missing? Edge cases not covered?
->
-> Reply with feedback, or **"Approved"** to finalize.
-
-**Wait for approval.**
-
-## Step 5 — Handoff
-
-Confirm completion with summary: screens specified, flows documented, components with states, edge cases and accessibility covered.
-
-Read `.spectre/next_steps_guide.md` and render Next Steps footer:
-
-```
-Next Steps | Phase: Scope | Status: UX Complete
-Recommendation: {contextual next action}
-Options: /create_plan, /create_tasks, /tdd
-```

package/plugins/spectre/hooks/scripts/load-knowledge.cjs

@@ -1,120 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * load-knowledge.cjs
- *
- * SessionStart hook that injects the apply skill content with embedded registry
- * directly into Claude's context.
- *
- * Reads:
- * - Apply skill from plugin: skills/spectre-apply/SKILL.md
- * - Registry from project: .claude/skills/spectre-recall/references/registry.toon
- *
- * Combines them by replacing the Registry Location section with actual registry content.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-function countRegistryEntries(lines) {
-  let count = 0;
-  for (const line of lines) {
-    if (line.trim() && line.includes('|') && !line.startsWith('#')) {
-      count++;
-    }
-  }
-  return count;
-}
-
-function stripFrontmatter(content) {
-  if (content.startsWith('---')) {
-    const end = content.indexOf('---', 3);
-    if (end !== -1) {
-      return content.slice(end + 3).trim();
-    }
-  }
-  return content;
-}
-
-function main() {
-  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || '';
-
-  const applySkillPath = path.join(pluginRoot, 'skills', 'spectre-apply', 'SKILL.md');
-
-  if (!fs.existsSync(applySkillPath)) {
-    process.exit(0);
-  }
-
-  // Paths - check new name first, fall back to old names for migration
-  let registryPath = path.join(projectDir, '.claude', 'skills', 'spectre-recall', 'references', 'registry.toon');
-  const oldRegistryPath = path.join(projectDir, '.claude', 'skills', 'spectre-find', 'references', 'registry.toon');
-
-  // Support old "spectre-find" path for projects that haven't migrated
-  if (!fs.existsSync(registryPath) && fs.existsSync(oldRegistryPath)) {
-    registryPath = oldRegistryPath;
-  }
-
-  // Read registry if it exists
-  let registryContent = '';
-  let entryCount = 0;
-  if (fs.existsSync(registryPath)) {
-    registryContent = fs.readFileSync(registryPath, 'utf8').trim();
-    const lines = registryContent ? registryContent.split('\n') : [];
-    entryCount = countRegistryEntries(lines);
-  }
-
-  // Read apply skill and strip frontmatter
-  let applyContent = fs.readFileSync(applySkillPath, 'utf8');
-  applyContent = stripFrontmatter(applyContent);
-
-  // Replace the Registry Location section with embedded registry or empty notice
-  let registrySection;
-  if (entryCount > 0) {
-    registrySection =
-      '## Registry\n\n' +
-      '**Format**: `skill-name|category|triggers|description`\n\n' +
-      '```\n' +
-      registryContent + '\n' +
-      '```\n\n' +
-      'Each entry corresponds to a skill that can be loaded via `Skill({skill-name})`\n\n' +
-      '**Categories:** feature, gotchas, patterns, decisions, procedures, integration, performance, testing, ux, strategy';
-  } else {
-    registrySection =
-      '## Registry\n\n' +
-      'No knowledge has been captured for this project yet. The behavioral rules in this document still apply.\n\n' +
-      'To capture knowledge from this session, use `/spectre:learn` after completing significant work.\n\n' +
-      '**Categories:** feature, gotchas, patterns, decisions, procedures, integration, performance, testing, ux, strategy';
-  }
-
-  // Replace the Registry Location section
-  applyContent = applyContent.replace(
-    /## Registry Location[\s\S]*?(?=## Workflow)/,
-    registrySection + '\n\n'
-  );
-
-  // Build final context
-  const context = `<spectre-knowledge>\n${applyContent}\n</spectre-knowledge>`;
-
-  // Visible notice
-  let visibleNotice;
-  if (entryCount > 0) {
-    visibleNotice = `\ud83d\udc7b spectre: ${entryCount} knowledge skills available`;
-  } else {
-    visibleNotice = '\ud83d\udc7b spectre: ready \u2014 capture knowledge with /spectre:learn';
-  }
-
-  const output = {
-    systemMessage: visibleNotice,
-    hookSpecificOutput: {
-      hookEventName: 'SessionStart',
-      additionalContext: context
-    }
-  };
-
-  process.stdout.write(JSON.stringify(output) + '\n');
-  process.exit(0);
-}
-
-main();

package/plugins/spectre/hooks/scripts/precompact-warning.cjs

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * precompact-warning.cjs
- *
- * PreCompact hook that suggests using /spectre:handoff + /clear
- * instead of auto-compact for better context continuity.
- */
-
-const output = {
-  systemMessage:
-    '\u26a0\ufe0f Auto-compact can cause context loss. ' +
-    'For full continuity: /spectre:handoff \u2192 /clear \u2192 new session. ' +
-    'Consider disabling auto-compact in /config.'
-};
-
-process.stdout.write(JSON.stringify(output) + '\n');
-process.exit(0);

package/plugins/spectre/hooks/scripts/register_learning.cjs

@@ -1,144 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * register_learning.cjs
- *
- * Registers a spectre learning and manages the project-level recall skill.
- *
- * Responsibilities:
- * 1. Create/update registry at .claude/skills/spectre-recall/references/registry.toon
- * 2. Read recall-template.md from plugin
- * 3. Generate .claude/skills/spectre-recall/SKILL.md with embedded registry
- *
- * Usage:
- *   node register_learning.cjs \
- *     --project-root "/path/to/project" \
- *     --skill-name "feature-my-feature" \
- *     --category "feature" \
- *     --triggers "keyword1, keyword2" \
- *     --description "Use when doing X or Y"
- */
-
-const fs = require('fs');
-const path = require('path');
-
-function getRegistryHeader() {
-  return [
-    '# SPECTRE Knowledge Registry',
-    '# Format: skill-name|category|triggers|description',
-    ''
-  ];
-}
-
-function updateRegistry(registryPath, entry, skillName) {
-  const entryPrefix = skillName + '|';
-  let lines;
-
-  if (fs.existsSync(registryPath)) {
-    const content = fs.readFileSync(registryPath, 'utf8').trim();
-    lines = content ? content.split('\n') : [];
-  } else {
-    lines = getRegistryHeader();
-  }
-
-  let entryExists = false;
-  const updatedLines = [];
-
-  for (const line of lines) {
-    if (line.startsWith(entryPrefix)) {
-      updatedLines.push(entry);
-      entryExists = true;
-    } else {
-      updatedLines.push(line);
-    }
-  }
-
-  if (!entryExists) {
-    updatedLines.push(entry);
-  }
-
-  let content = updatedLines.join('\n');
-  if (!content.endsWith('\n')) {
-    content += '\n';
-  }
-
-  fs.writeFileSync(registryPath, content);
-  return content;
-}
-
-function generateFindSkill(findSkillPath, templatePath, registryContent) {
-  if (!fs.existsSync(templatePath)) {
-    process.stderr.write(`Warning: Template not found at ${templatePath}\n`);
-    return;
-  }
-
-  const template = fs.readFileSync(templatePath, 'utf8');
-  const skillContent = template.replace('{{REGISTRY}}', registryContent.trim());
-
-  fs.mkdirSync(path.dirname(findSkillPath), { recursive: true });
-  fs.writeFileSync(findSkillPath, skillContent);
-}
-
-function parseArgs(argv) {
-  const args = {};
-  const flags = ['--project-root', '--skill-name', '--category', '--triggers', '--description'];
-
-  for (let i = 0; i < argv.length; i++) {
-    if (flags.includes(argv[i]) && i + 1 < argv.length) {
-      // Convert --project-root to projectRoot
-      const key = argv[i].slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-      args[key] = argv[i + 1];
-      i++;
-    }
-  }
-
-  return args;
-}
-
-function main() {
-  const args = parseArgs(process.argv.slice(2));
-
-  const required = ['projectRoot', 'skillName', 'category', 'triggers', 'description'];
-  for (const key of required) {
-    if (!args[key]) {
-      process.stderr.write(`Error: missing required argument --${key.replace(/[A-Z]/g, c => '-' + c.toLowerCase())}\n`);
-      process.exit(1);
-    }
-  }
-
-  const projectRoot = args.projectRoot;
-
-  // New paths: registry lives inside spectre-recall skill
-  const recallDir = path.join(projectRoot, '.claude', 'skills', 'spectre-recall');
-  const registryDir = path.join(recallDir, 'references');
-  const registryPath = path.join(registryDir, 'registry.toon');
-  const recallSkillPath = path.join(recallDir, 'SKILL.md');
-
-  // Template is in the plugin — resolve via env var (hooks) or __filename (manual invocation)
-  let pluginRoot;
-  if (process.env.CLAUDE_PLUGIN_ROOT) {
-    pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
-  } else {
-    // Fallback: resolve relative to this script
-    // Script is at: <plugin_root>/hooks/scripts/register_learning.cjs
-    pluginRoot = path.resolve(__dirname, '..', '..');
-  }
-  const templatePath = path.join(pluginRoot, 'skills', 'spectre-learn', 'references', 'recall-template.md');
-
-  // Ensure directories exist
-  fs.mkdirSync(registryDir, { recursive: true });
-
-  // Build the registry entry
-  const entry = `${args.skillName}|${args.category}|${args.triggers}|${args.description}`;
-
-  // Update registry and get full content
-  const registryContent = updateRegistry(registryPath, entry, args.skillName);
-
-  // Generate recall skill with embedded registry
-  generateFindSkill(recallSkillPath, templatePath, registryContent);
-
-  process.stdout.write(`Registered: ${entry}\n`);
-}
-
-main();