@codename_inc/spectre 3.7.0 → 5.0.0

package/plugins/spectre-codex/skills/ux/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: "ux"
+description: "👻 | Define user flows, components, and UX behavior — generates the UX spec for a feature - primary agent"
+user-invocable: true
+---
+
+# ux
+
+## Input Handling
+
+Treat the current command arguments as this workflow's input. When invoked from a slash command, use the forwarded `$ARGUMENTS` value.
+
+# ux: 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 scope and requirements** in this precedence (read whichever exist FULLY, no offset/limit):
+   - `docs/tasks/{branch}/concepts/scope.md` — the canonical scope doc (preferred)
+   - `docs/tasks/{branch}/specs/prd.md` — if a PRD was generated separately
+   - `docs/tasks/{branch}/task_summary.md` — if present
+   - **If none exist** → ask the user for scope context (or recommend `scope` first) before proceeding.
+2. **Research patterns**: Dispatch `@patterns` to find existing screens/components similar to what we're building. Note conventions, reusable elements, and any design tokens.
+3. **Identify user segments**: List the user segments this feature serves — first-time vs returning, anonymous vs signed-in, free vs paid, role-based variants. UX often diverges across segments and missing this is a common cause of rework.
+4. **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.
+
+**Per user segment**: Call out where flows diverge (e.g., "First-time users see X tour; returning users skip directly to Y").
+
+After writing all flows, propose a specific take rather than asking open-ended:
+
+> **User Flows — Proposed**
+>
+> I've mapped {N} flows across {M} user segments: {list with one-line summaries}
+>
+> **Key segmentation calls**: [where flows diverge by user state and why]
+>
+> Push back on anything wrong, missing, or over-/under-segmented. 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, segment variants.
+
+If significant gaps, ask 3–5 targeted questions (empty states, error handling, loading, limits, segment differences). 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. **User Segments** — Each segment served, what's different about their UX (e.g., first-time onboarding, role-based permissions, free vs paid limits, anon vs signed-in)
+3. **Screens** — Every screen: name, purpose (1 line), navigation relationships
+4. **Flows** — Formalized from Stage 1 with alternate paths (validation fail, cancel, network error). Include per-segment branches where they diverge.
+5. **Layouts** — Per screen: header/main/footer structure + responsive behavior (desktop >1024, tablet 768–1024, mobile <768)
+6. **Components** — Each interactive element: purpose, location, applicable states (see State Vocabulary below)
+7. **Interactions** — Table format: Element | Action | Result (exhaustive)
+8. **States** — Table format: State | Trigger | Appearance | Available Actions
+9. **Content** — Exact copy: page titles, buttons, empty states, error messages, confirmation dialogs
+10. **Edge Cases** — Limits/boundaries, null/long data handling, permissions, offline/network failures, segment-specific edge cases
+11. **Accessibility** — Tab order, keyboard actions (Enter/Space/Escape), screen reader announcements, focus management
+
+### State Vocabulary
+
+Use these state categories where applicable. Not every component needs every state — pick what's relevant for the feature.
+
+- **Visual states** (per interactive element): default, hover, focus, active/pressed, disabled
+- **Data states** (per data view): empty, loading, partial-loaded, loaded, error, stale/refreshing
+- **Form states**: pristine, dirty, touched, submitting, submitted-success, submitted-error, validation-error per field
+- **Selection states**: none, single, multi, partial-selection, all-selected
+- **Sync states** (collaborative or async UI): optimistic, pending, conflict, resolved
+- **Network states** (where relevant): online, offline, reconnecting
+
+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? Segment differences captured?
+>
+> **Want a prototype to validate visually before approving?** `prototype` will render this spec (high-fi, no synthesis) and flag assumptions where I had to fill in details — catches issues prose review misses. Reply `prototype` to run it now.
+>
+> Otherwise, reply with feedback, or **"Approved"** to finalize.
+
+**Wait for approval, feedback, or prototype request.** If user replies `prototype`, invoke `prototype` (the post-ux mode auto-detects the complete ux.md). Once prototype completes and any spec updates from filled assumptions are applied, return here for final approval.
+
+## Step 5 — Handoff
+
+Confirm completion with summary: screens specified, segments addressed, 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 — if no prototype was generated, suggest prototype to validate the spec visually before /plan}
+Options: prototype (validate spec visually), create_plan, create_tasks, tdd
+```

package/plugins/spectre-codex/skills/validate/SKILL.md

@@ -0,0 +1,352 @@
+---
+name: "validate"
+description: "👻 | Comprehensive post implementation requirement validation using subagents"
+user-invocable: true
+---
+
+# validate
+
+## Input Handling
+
+Treat the current command arguments as this workflow's input. When invoked from a slash command, use the forwarded `$ARGUMENTS` value.
+
+
+# validate: Scope delivery verification and gap analysis
+
+## Description
+
+- **What** — Validate implementation against scope/tasks docs, dispatch parallel subagents per area, produce single actionable gap remediation document.
+- **Approach** — Primary agent chunks work by scope items or parent tasks, dispatches one @analyst per area IN PARALLEL. Each subagent validates their area including E2E UX accessibility.
+- **Outcome** — Single `validation_gaps.md` with actionable tasks ready for immediate implementation.
+
+## Core Validation Principle
+
+> **"Definition ≠ Connection ≠ Reachability"**
+
+Three levels of implementation completeness:
+1. **Defined**: Code exists in a file
+2. **Connected**: Code is imported/called by other code
+3. **Reachable**: A user action can trigger the code path
+
+Validation must verify all three levels. A feature with Level 1 but not Level 2 or 3 is NOT complete—it's dead code that happens to match the requirement description.
+
+When verifying any implementation:
+- Don't stop at "function X exists in file Y"
+- Continue to "function X is called by Z at file:line"
+- Continue to "Z is triggered when user does W"
+
+## ARGUMENTS Input
+
+**REQUIRED**: User must provide scope documents to validate against.
+
+<ARGUMENTS> $ARGUMENTS </ARGUMENTS>
+
+## Step (1/4) - Gather Validation Inputs
+
+- **Action** — CheckArguments: Verify user provided scope documents.
+
+  - **If** ARGUMENTS contains file paths or "use thread context" → proceed
+
+  - **Else** → Immediately reply:
+
+    > "What should I validate against? Please provide:
+    >
+    > - Path to scope document (e.g., `docs/tasks/main/scope.md`)
+    > - Path to tasks document (e.g., `docs/tasks/main/tasks.md`)
+    > - Or say 'use thread context' to validate against our conversation"
+
+  - **Wait** — User provides validation inputs
+
+- **Action** — ReadScopeDocs: Read provided documents completely (no limits).
+
+  - Extract all requirements, acceptance criteria, deliverables
+  - Document scope boundaries (in-scope / out-of-scope)
+  - Note constraints and success metrics
+
+- **Action** — ChunkIntoValidationAreas: Break scope into discrete validation areas.
+
+  - **From tasks.md**: Each parent task (e.g., \[1.1\], \[1.2\]) = one validation area
+  - **From scope.md**: Each "In Scope" item = one validation area
+  - **From thread context**: Each discussed feature/requirement = one validation area
+  - Aim for 3-8 validation areas (merge small items, split large ones)
+
+- **Action** — CreateValidationManifest: Document chunks before dispatch.
+
+  ```plaintext
+  Validation Areas:
+  1. {Area Name} — {What to validate}
+     - Source: {requirement text from scope doc}
+     - Expected: {what should exist}
+  2. ...
+  ```
+
+## Step (2/4) - Dispatch Parallel Validation Agents
+
+**CRITICAL**: Dispatch ALL validation agents in parallel in a SINGLE message with multiple Task tool calls. Do NOT dispatch sequentially.
+
+- **Action** — DispatchValidators: Launch one @analyst per validation area IN PARALLEL.
+
+  **Subagent Prompt Template**:
+
+  ```plaintext
+  You are validating scope delivery for ONE specific area.
+  
+  ## Context Documents
+  - Scope: {path or "thread context"}
+  - Tasks: {path if provided}
+  - Branch: {branch_name}
+  
+  ## Your Validation Area
+  **Area**: {area_name}
+  **Source Requirement**: {exact text from scope/tasks doc}
+  **Expected Deliverables**: {what should exist}
+  
+  ## Your Task
+  1. Investigate YOUR SPECIFIC AREA only
+  2. For each requirement, determine:
+     - **Status**: ✅ Delivered | ⚠️ Partial | 🔌 Dead Code | ❌ Missing
+       - ✅ **Delivered**: Defined AND connected AND reachable from user action
+       - ⚠️ **Partial**: Code exists but has broken/missing connections
+       - 🔌 **Dead Code**: Code exists but has zero usage sites
+       - ❌ **Missing**: Code does not exist
+     - **Evidence**: Must include BOTH:
+       1. Definition site: `file:line` where code is defined
+       2. Usage site: `file:line` where code is called/rendered
+       - If you can only cite definition without usage → status is ⚠️ or 🔌
+     - **Gap**: What's missing (if any)
+
+  3. **CRITICAL - Reachability Verification**:
+     - Trace the COMPLETE chain from user action to implementation:
+       - Entry point: What user action triggers this? (click, route, event)
+       - Call chain: How does execution flow to the implementation?
+       - Terminal point: What side effect/UI change occurs?
+     - A broken link at ANY point = ⚠️ NOT FULLY DELIVERED
+     - For every function/component, grep for USAGE not just DEFINITION:
+       - Functions: Search for `functionName(` to find invocations
+       - Components: Search for `<ComponentName` to find render sites
+       - Hooks: Search for `useHookName(` to find consumers
+       - Props: Search for `propName={` to find where passed
+     - Zero usage sites = 🔌 Dead Code
+
+  4. **CRITICAL - Consumer-First Validation (Render-Backward Trace)**:
+     For UI features, start from the FINAL RENDER and trace BACKWARDS:
+     - What component renders the feature output? (exact JSX location)
+     - What variable does that JSX use? (exact variable name)
+     - Where does that variable come from? (hook, prop, computed value)
+     - Trace back to the user action. Is every link connected?
+
+     Example (filter feature):
+     - Renders: `BoardColumn` receives `tasks` prop at line 45
+     - Variable: `tasks` comes from `getFilteredTasksForBoard(board.id)`
+     - Source: `getFilteredTasksForBoard` uses... `getTasksForBoard` from drag hook
+     - ❌ BROKEN: This bypasses `displayTasks` from filter hook!
+
+     If you can only trace forward (definition → usage) but NOT backward
+     (render → source), you haven't verified the last mile.
+
+  5. **CRITICAL - Dead Computation Detection**:
+     List every computed value that is NOT directly consumed by a render:
+     - For each hook return value, grep for where it's destructured/used
+     - For each computed const, grep for where it's referenced
+     - A value that's computed but never reaches JSX = 🔌 Dead Code
+
+     Example:
+     - `displayTasks` from `useKanbanFilters` → used where?
+       - Passed to `TasksHeroHeader` ✓
+       - Used in `getFilteredTasksForBoard`? ❌ NO — uses different source
+     - Computed but not in render chain = BUG
+
+  6. **Old Code Path Audit**:
+     When new functionality replaces old patterns:
+     - What OLD code handled this before? (imports, hooks, functions)
+     - Is the old code still being called anywhere?
+     - Are there duplicate data sources for the same concern?
+     - If old path still active → ⚠️ Partial (new code bypassed)
+
+  7. Check for scope creep: anything beyond the requirement
+  
+  ## Output Format
+  ```
+
+  AREA: {area_name} STATUS: {overall: Delivered | Partial | Dead Code | Missing}
+
+  REQUIREMENTS:
+
+  - \[REQ-1\] {requirement}
+    Status: {✅|⚠️|🔌|❌}
+    Definition: {file:line where defined}
+    Usage: {file:line where called/rendered, or "NONE FOUND"}
+    Reachability: {user action → ... → this code, or "NOT REACHABLE"}
+    Render Chain: {JSX ← variable ← source ← user action, or "BROKEN AT {link}"}
+    Gap: {what's missing}
+    Remediation: {specific fix — what to wire, what to replace, what to add}
+      - Produces: {what the fix outputs}
+      - Consumed by: {what should use it}
+      - Replaces: {old path to remove, or "N/A"}
+
+  DEAD COMPUTATIONS:
+  - {variable name} in {file}: computed but not consumed by render
+    - Remediation: {wire to X, or delete if unnecessary}
+
+  OLD CODE PATHS:
+  - {old function/hook}: still active at {file:line}, bypasses new implementation
+    - Remediation: {replace calls with new path, or remove}
+
+  SCOPE CREEP: {any features beyond scope}
+
+  SUMMARY: {1-2 sentences}
+
+  ```
+
+**Verification Patterns for Subagents**:
+
+| Checking | Search Pattern | Meaning |
+|----------|---------------|---------|
+| Function called | `functionName\(` | Invocation exists |
+| Component renders | `<ComponentName` | JSX usage exists |
+| Hook consumed | `useHookName\(` | Hook is used |
+| Prop passed | `propName={` | Parent passes prop |
+| Export imported | `import.*Name` | Module consumed |
+
+**Common broken link patterns to check**:
+- Callback defined but never passed as prop
+- Prop received but never used in component body
+- Function exported but never imported elsewhere
+- Type defined but never used in signatures
+- Switch case exists but condition never triggers
+- **Hook returns value that's destructured but never used in JSX**
+- **New data source created but old source still used in render**
+- **Computed value stored in variable but render uses different variable**
+- **Filter/transform function created but rendering bypasses it**
+
+**Last-Mile Anti-Patterns** (these cause "works in code, broken in UI"):
+- `displayTasks` computed but `getTasksForBoard` called in render
+- Handler created but onClick still points to old handler
+- New hook created but component still imports old hook
+- State updated correctly but wrong variable passed to child component
+
+- **Wait** — All validation agents complete
+
+## Step (3/4) - Consolidate & Create Gap Remediation Tasks
+
+- **Action** — ConsolidateFindings: Merge all subagent outputs.
+
+  - Aggregate status across all areas
+  - Compile gaps by priority (Critical/Medium/Low)
+  - Note any scope creep findings
+
+- **Action** — FinalWiringChecklist: Before marking any area complete, verify:
+
+  | Check | Question |
+  |-------|----------|
+  | Consumer connected? | Does every new function/hook have a consumer that uses its output? |
+  | Render chain complete? | Can you trace from JSX ← variable ← hook ← user action without breaks? |
+  | Old paths removed? | If replacing old code, is the old path dead or redirected? |
+  | No orphaned computation? | Is every computed value actually used in a render path? |
+  | No duplicate sources? | Is there only ONE data source for each concern (not old + new)? |
+
+  **CRITICAL**: If any check fails for an area marked ✅, downgrade to ⚠️ and add gap task.
+
+- **Action** — DetermineOutputDir:
+
+  - `branch_name=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown)`
+  - **If** user specifies path → `OUT_DIR={that value}`
+  - **Else** → `OUT_DIR=docs/tasks/{branch_name}`
+  - `mkdir -p "${OUT_DIR}/validation"`
+
+- **Action** — CreateValidationGapsDoc: Generate `{OUT_DIR}/validation/validation_gaps.md`.
+
+  **Document Structure**:
+
+  ```markdown
+  # Validation Gaps: {task_name}
+  *Generated: {timestamp}*
+
+  ## Summary
+  - **Overall Status**: {Complete | Needs Work | Significant Gaps}
+  - **Requirements**: {X of Y} delivered
+  - **Gaps Found**: {count} requiring remediation
+  - **Scope Creep**: {count} items (document or remove)
+
+  ---
+
+  ## Gap Remediation Tasks
+
+  ### 📦 Phase 1: Critical Gaps
+
+  #### 📋 [1.1] {Gap Title - e.g., "Connect auth flow to login page"}
+  **Requirement**: {original requirement text}
+  **Current State**: {what exists now — definition site if code exists}
+  **Gap**: {what's missing — broken link in the chain}
+
+  - [ ] **1.1.1** {Specific action - e.g., "Wire LoginButton onClick to auth handler"}
+    - **Produces**: {output this creates — e.g., "onClick handler calling authService.login()"}
+    - **Consumed by**: {what uses this — e.g., "LoginButton component render"}
+    - **Replaces**: {old code path — e.g., "inline console.log in onClick" or "N/A"}
+    - [ ] {Verifiable outcome 1}
+    - [ ] {Verifiable outcome 2}
+
+  - [ ] **1.1.2** {Specific action - e.g., "Add login route to app router"}
+    - **Produces**: {output — e.g., "/login route rendering LoginPage"}
+    - **Consumed by**: {consumer — e.g., "App router, navigated via authService redirect"}
+    - [ ] {Verifiable outcome 1}
+    - [ ] {Verifiable outcome 2}
+
+  #### 📋 [1.2] {Next Gap Title}
+  ...
+
+  ### 📦 Phase 2: Medium Priority Gaps
+  ...
+
+  ### 📦 Phase 3: Low Priority / Polish
+  ...
+  
+  ---
+
+  ## Scope Creep Review
+  Items implemented beyond original scope:
+  - [ ] **{Feature}**: {Keep and document | Remove | Discuss}
+    - Evidence: {file:line}
+    - Recommendation: {action}
+
+  ---
+
+  ## Validation Coverage
+  | Area | Status | Definition | Usage | Render Chain |
+  |------|--------|------------|-------|--------------|
+  | {area 1} | ✅ | {file:line} | {file:line} | JSX ← var ← source ✓ |
+  | {area 2} | ⚠️ | {file:line} | {file:line} | Broken at {link} |
+  | {area 3} | 🔌 | {file:line} | NONE | Dead computation |
+  | {area 4} | ❌ | — | — | — |
+
+  ## Dead Computations Found
+  | Variable | File | Computed By | Should Be Consumed By |
+  |----------|------|-------------|----------------------|
+  | {displayTasks} | {useKanbanFilters.ts} | {applyTaskFilters} | {KanbanBoard render} |
+
+  ## Old Code Paths Still Active
+  | Old Path | Location | Should Be Replaced By | Impact |
+  |----------|----------|----------------------|--------|
+  | {getTasksForBoard} | {useKanbanDrag:45} | {displayTasks from useKanbanFilters} | Bypasses new filter |
+
+  ```
+
+## Step (4/4) - Present Results
+
+- **Action** — PresentResults: Show validation summary.
+
+  > ## Validation Complete
+    **> **Status**: {Complete | Needs Work | Significant Gaps}
+  >
+  > - {X of Y} requirements delivered
+  > - {N} gaps requiring remediation
+  > - {N} scope creep items to review
+    **> **Gap Remediation Doc**: `{OUT_DIR}/validation/validation_gaps.md`
+  >
+  > {1-2 sentence summary of key findings}
+
+- **Action** — RenderFooter: Render Next Steps footer using `Skill(spectre-guide)` skill
+
+## Next Steps
+
+See `Skill(spectre)` skill for footer format and command options. 

package/src/config.test.js

@@ -90,8 +90,9 @@ test('buildSessionStartOutput returns official SessionStart payload from the lat
   assert.match(overrideContent, /<!-- spectre-session:end -->/);
   assert.match(overrideContent, /<!-- spectre-knowledge:start -->/);
   assert.match(overrideContent, /## SPECTRE Knowledge Context/);
-  assert.match(overrideContent, /If ANY entry's triggers or description match your current task, you MUST load the skill FIRST/);
-  assert.match(overrideContent, /feature-auth\|feature\|auth, login\|Use when modifying auth flows/);
+  assert.match(overrideContent, /If ANY skill's triggers or description match your current task, you MUST load the skill FIRST/);
+  assert.doesNotMatch(overrideContent, /feature-auth\|feature\|auth, login\|Use when modifying auth flows/);
+  assert.match(overrideContent, /skill list already has what you need/);
   assert.match(overrideContent, /<!-- spectre-knowledge:end -->/);
   assert.ok(fs.existsSync(path.join(tmp, '.agents', 'skills', 'spectre-recall', 'SKILL.md')));
 });
@@ -123,12 +124,12 @@ test('buildSessionStartOutput keeps knowledge active when no handoff exists and
   const { buildSessionStartOutput } = await import('./lib/project.js');
   const output = buildSessionStartOutput(tmp, { source: 'clear' });
   assert.ok(output);
-  assert.equal(output.systemMessage, '🟢 👻 SPECTRE active | 👻 spectre: ready — capture knowledge with spectre-learn');
+  assert.equal(output.systemMessage, '🟢 👻 SPECTRE active | 👻 spectre: ready — capture knowledge with /spectre:learn');
   const overrideContent = fs.readFileSync(path.join(tmp, 'AGENTS.override.md'), 'utf8');
   assert.match(overrideContent, /User content before\./);
   assert.match(overrideContent, /User content after\./);
   assert.doesNotMatch(overrideContent, /spectre-session:start/);
   assert.match(overrideContent, /spectre-knowledge:start/);
-  assert.match(overrideContent, /No knowledge has been captured for this project yet/);
-  assert.match(overrideContent, /use `spectre-learn` after completing significant work/);
+  assert.match(overrideContent, /If ANY skill's triggers or description match your current task, you MUST load the skill FIRST/);
+  assert.match(overrideContent, /Capture via `Skill\(learn\)`/);
 });

package/src/install.test.js

@@ -38,32 +38,39 @@ test('project install writes workflow skills, agent config, and official Session
     await main(['install', 'codex', '--scope', 'project', '--project-dir', projectDir]);
 
     const codeHome = path.join(projectDir, '.codex');
-    const scopeSkillPath = path.join(codeHome, 'skills', 'spectre-scope', 'SKILL.md');
+    const scopeSkillPath = path.join(codeHome, 'skills', 'scope', 'SKILL.md');
     assert.ok(fs.existsSync(scopeSkillPath));
-    assert.match(fs.readFileSync(scopeSkillPath, 'utf8'), /Treat the current user request as the input arguments for this workflow/);
-    assert.match(fs.readFileSync(scopeSkillPath, 'utf8'), /This is the Codex skill replacement for the deprecated custom prompt \/spectre:scope/);
+    const scopeSkill = fs.readFileSync(scopeSkillPath, 'utf8');
+    assert.match(scopeSkill, /# scope: Interactive Feature Scoping/);
+    assert.doesNotMatch(scopeSkill, /This is the Codex skill replacement for the deprecated custom prompt \/spectre:scope/);
+    assert.doesNotMatch(scopeSkill, /Skill\(spectre-scope\)/);
 
-    const applySkillPath = path.join(codeHome, 'skills', 'spectre-apply', 'SKILL.md');
+    const applySkillPath = path.join(codeHome, 'skills', 'apply', 'SKILL.md');
     assert.ok(fs.existsSync(applySkillPath));
-    assert.match(fs.readFileSync(applySkillPath, 'utf8'), /If ANY entry's triggers or description match your current task, you MUST load the skill FIRST/);
+    assert.match(fs.readFileSync(applySkillPath, 'utf8'), /If ANY skill's triggers or description match your current task, you MUST load the skill FIRST/);
 
-    const learnSkillPath = path.join(codeHome, 'skills', 'spectre-learn', 'SKILL.md');
+    const learnSkillPath = path.join(codeHome, 'skills', 'learn', 'SKILL.md');
     assert.ok(fs.existsSync(learnSkillPath));
     assert.match(fs.readFileSync(learnSkillPath, 'utf8'), /### 13\. Register the Learning/);
     assert.match(fs.readFileSync(learnSkillPath, 'utf8'), /\.agents\/skills\/spectre-recall\/references\/registry\.toon/);
+    assert.ok(fs.existsSync(path.join(codeHome, 'skills', 'learn', 'references', 'recall-template.md')));
 
     const agentPath = path.join(codeHome, 'spectre', 'agents', 'dev.toml');
     assert.ok(fs.existsSync(agentPath));
     const agentConfig = fs.readFileSync(agentPath, 'utf8');
     assert.match(agentConfig, /name = "dev"/);
     assert.match(agentConfig, /description = /);
+    assert.doesNotMatch(agentConfig, /^model = /m);
+    assert.doesNotMatch(agentConfig, /^model_reasoning_effort = /m);
+    assert.match(agentConfig, /sandbox_mode = "workspace-write"/);
     assert.match(agentConfig, /developer_instructions = \"\"\"/);
     assert.doesNotMatch(agentConfig, /base_instructions = /);
 
     const config = fs.readFileSync(path.join(codeHome, 'config.toml'), 'utf8');
     assert.match(config, /suppress_unstable_features_warning = true/);
     assert.match(config, /\[agents\.spectre_dev\]/);
-    assert.match(config, /codex_hooks = true/);
+    assert.match(config, /^hooks = true$/m);
+    assert.doesNotMatch(config, /codex_hooks = true/);
     assert.match(config, /multi_agent = true/);
     assert.doesNotMatch(config, /session_start = /);
     assert.doesNotMatch(config, /pre_session_start/);
@@ -76,10 +83,22 @@ test('project install writes workflow skills, agent config, and official Session
     assert.deepEqual(hooksConfig.hooks.SessionStart[0].hooks, [
       {
         type: 'command',
-        command: `node '${path.join(codeHome, 'spectre', 'hooks', 'session-start.mjs')}'`,
-        statusMessage: 'Spectre: loading session context'
+        command: `node '${path.join(codeHome, 'spectre', 'hooks', 'scripts', 'bootstrap.mjs')}'`
+      },
+      {
+        type: 'command',
+        command: `node '${path.join(codeHome, 'spectre', 'hooks', 'scripts', 'handoff-resume.mjs')}'`
+      },
+      {
+        type: 'command',
+        command: `node '${path.join(codeHome, 'spectre', 'hooks', 'scripts', 'load-knowledge.mjs')}'`
       }
     ]);
+    assert.equal(hooksConfig.hooks.PreCompact, undefined);
+    assert.ok(fs.existsSync(path.join(codeHome, 'spectre', 'hooks', 'hooks.json')));
+    assert.ok(fs.existsSync(path.join(codeHome, 'spectre', 'hooks', 'scripts', 'load-knowledge.mjs')));
+    assert.ok(!fs.existsSync(path.join(codeHome, 'spectre', 'hooks', 'scripts', 'precompact-warning.mjs')));
+    assert.ok(!fs.existsSync(path.join(codeHome, 'spectre', 'hooks', 'session-start.mjs')));
     assert.ok(fs.existsSync(path.join(codeHome, 'spectre', 'tools', 'sync-session-override.mjs')));
     assert.ok(fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-recall', 'SKILL.md')));
     assert.ok(fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-recall', 'references', 'registry.toon')));
@@ -93,6 +112,25 @@ test('project install writes workflow skills, agent config, and official Session
     assert.ok(!fs.existsSync(path.join(projectDir, '.agents', 'skills', 'spectre-session')));
     assert.ok(!fs.existsSync(path.join(projectDir, '.spectre', 'bin', 'codex')));
     assert.ok(!fs.existsSync(path.join(codeHome, 'prompts', 'spectre:scope.md')));
+
+    const knowledgeOutput = execFileSync(process.execPath, [
+      path.join(codeHome, 'spectre', 'hooks', 'scripts', 'load-knowledge.mjs')
+    ], {
+      cwd: projectDir,
+      env: {
+        ...process.env,
+        CODEX_HOME: codeHome
+      },
+      encoding: 'utf8'
+    }).trim();
+    const parsedKnowledgeOutput = JSON.parse(knowledgeOutput);
+    assert.deepEqual(parsedKnowledgeOutput.hookSpecificOutput, { hookEventName: 'SessionStart' });
+    assert.match(parsedKnowledgeOutput.systemMessage, /spectre: ready/);
+    const knowledgeOverride = fs.readFileSync(path.join(projectDir, 'AGENTS.override.md'), 'utf8');
+    assert.match(knowledgeOverride, /<!-- spectre-knowledge:start -->/);
+    assert.match(knowledgeOverride, /# Apply Knowledge/);
+    assert.doesNotMatch(knowledgeOutput, /additionalContext/);
+
     execFileSync('codex', ['--version'], {
       env: {
         ...process.env,
@@ -109,6 +147,56 @@ test('project install writes workflow skills, agent config, and official Session
   }
 });
 
+test('user install wires generated hooks that run outside project manifests', { concurrency: false }, () => {
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spectre-codex-home-'));
+  const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spectre-codex-workspace-'));
+  execFileSync('git', ['init', '-b', 'main'], { cwd: workspaceDir, stdio: 'ignore' });
+
+  execFileSync(process.execPath, [
+    path.join(process.cwd(), 'bin', 'spectre.js'),
+    'install',
+    'codex',
+    '--scope',
+    'user',
+    '--project-dir',
+    workspaceDir
+  ], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      HOME: homeDir,
+      CODEX_HOME: ''
+    },
+    stdio: 'ignore'
+  });
+
+  const codeHome = path.join(homeDir, '.codex');
+  const hooksConfig = JSON.parse(fs.readFileSync(path.join(codeHome, 'hooks.json'), 'utf8'));
+  const sessionHooks = hooksConfig.hooks.SessionStart.flatMap(group => group.hooks ?? []);
+  assert.ok(sessionHooks.some(hook => hook.command.includes('spectre/hooks/scripts/load-knowledge.mjs')));
+  assert.ok(sessionHooks.every(hook => !hook.command.includes('spectre/hooks/session-start.mjs')));
+  assert.ok(fs.existsSync(path.join(codeHome, 'spectre', 'hooks', 'scripts', 'load-knowledge.mjs')));
+  assert.ok(!fs.existsSync(path.join(codeHome, 'spectre', 'hooks', 'session-start.mjs')));
+
+  const output = execFileSync(process.execPath, [
+    path.join(codeHome, 'spectre', 'hooks', 'scripts', 'load-knowledge.mjs')
+  ], {
+    cwd: workspaceDir,
+    env: {
+      ...process.env,
+      HOME: homeDir
+    },
+    encoding: 'utf8'
+  }).trim();
+
+  assert.ok(!fs.existsSync(path.join(workspaceDir, '.spectre', 'manifest.json')));
+  const parsedOutput = JSON.parse(output);
+  assert.match(parsedOutput.systemMessage, /spectre: ready/);
+  assert.deepEqual(parsedOutput.hookSpecificOutput, { hookEventName: 'SessionStart' });
+  assert.ok(!fs.existsSync(path.join(workspaceDir, 'AGENTS.override.md')));
+  assert.doesNotMatch(output, /additionalContext/);
+});
+
 test('project install removes legacy bridge artifacts while preserving non-managed AGENTS content', { concurrency: false }, async () => {
   const projectDir = makeProject();
   fs.writeFileSync(
@@ -209,8 +297,9 @@ test('project install preserves unrelated hooks.json handlers while adding Spect
     ]);
     assert.ok(Array.isArray(hooksConfig.hooks.SessionStart));
     assert.ok(hooksConfig.hooks.SessionStart.some(group =>
-      Array.isArray(group.hooks) && group.hooks.some(hook => hook.command.includes('spectre/hooks/session-start.mjs'))
+      Array.isArray(group.hooks) && group.hooks.some(hook => hook.command.includes('spectre/hooks/scripts/load-knowledge.mjs'))
     ));
+    assert.equal(hooksConfig.hooks.PreCompact, undefined);
   } finally {
     if (previousCodexHome == null) {
       delete process.env.CODEX_HOME;
@@ -246,7 +335,7 @@ test('project uninstall removes managed workflow skills, agent config, and proje
 
     const codeHome = path.join(projectDir, '.codex');
 
-    assert.ok(!fs.existsSync(path.join(codeHome, 'skills', 'spectre-scope')));
+    assert.ok(!fs.existsSync(path.join(codeHome, 'skills', 'scope')));
     assert.ok(!fs.existsSync(path.join(codeHome, 'spectre')));
 
     const config = fs.readFileSync(path.join(codeHome, 'config.toml'), 'utf8');