opencode-goopspec 0.1.0 → 0.1.2

package/dist/index.js

@@ -27635,6 +27635,175 @@ Available agents: ${available.join(", ")}`;
   });
 }
 
+// src/tools/goop-reference/index.ts
+function formatResourceInfo(resource, _category) {
+  const desc = resource.frontmatter.description ? `: ${resource.frontmatter.description}` : "";
+  const categoryTag = resource.frontmatter.category ? ` (${resource.frontmatter.category})` : "";
+  return `- **${resource.name}**${desc}${categoryTag}`;
+}
+function getSection(resource, section) {
+  if (!section)
+    return null;
+  const sectionLower = section.toLowerCase();
+  for (const [key, value] of Object.entries(resource.frontmatter)) {
+    if (key.toLowerCase() === sectionLower && typeof value === "string") {
+      return value;
+    }
+  }
+  const lines = resource.body.split(`
+`);
+  let capturing = false;
+  let capturedLines = [];
+  const sectionPattern = new RegExp(`^##?\\s*${section}`, "i");
+  for (const line of lines) {
+    if (sectionPattern.test(line)) {
+      capturing = true;
+      capturedLines = [line];
+      continue;
+    }
+    if (capturing) {
+      if (/^##?\s/.test(line) && !line.startsWith("###")) {
+        break;
+      }
+      capturedLines.push(line);
+    }
+  }
+  return capturedLines.length > 0 ? capturedLines.join(`
+`).trim() : null;
+}
+function createGoopReferenceTool(ctx) {
+  return tool({
+    description: `Load reference documents or templates for specialized knowledge.
+
+**References** provide protocols, checklists, and patterns:
+- subagent-protocol: How subagents communicate with orchestrator
+- deviation-rules: When to auto-fix vs ask user
+- security-checklist: Security verification checklist
+- response-format: Standardized agent response formats
+
+**Templates** provide document structures:
+- spec: SPEC.md template for requirements
+- blueprint: BLUEPRINT.md template for execution plans
+- chronicle: CHRONICLE.md template for progress tracking
+
+Use \`list: true\` to see all available resources.
+Use \`type\` to filter: "reference" or "template" or "all".
+Use \`section\` to extract a specific section from the document.`,
+    args: {
+      name: tool.schema.string().optional(),
+      type: tool.schema.enum(["reference", "template", "all"]).optional(),
+      section: tool.schema.string().optional(),
+      list: tool.schema.boolean().optional()
+    },
+    async execute(args, _context) {
+      const resourceType = args.type || "all";
+      if (args.list || !args.name) {
+        const lines2 = [];
+        if (resourceType === "all" || resourceType === "reference") {
+          const refs = ctx.resolver.resolveAll("reference");
+          if (refs.length > 0) {
+            lines2.push(`# Available References
+`);
+            lines2.push(`*Protocols, checklists, and patterns for agents*
+`);
+            for (const ref of refs) {
+              lines2.push(formatResourceInfo(ref, "reference"));
+            }
+            lines2.push("");
+          }
+        }
+        if (resourceType === "all" || resourceType === "template") {
+          const templates = ctx.resolver.resolveAll("template");
+          if (templates.length > 0) {
+            lines2.push(`# Available Templates
+`);
+            lines2.push(`*Document structures for GoopSpec artifacts*
+`);
+            for (const tmpl of templates) {
+              lines2.push(formatResourceInfo(tmpl, "template"));
+            }
+            lines2.push("");
+          }
+        }
+        if (lines2.length === 0) {
+          return "No references or templates found.";
+        }
+        lines2.push("---");
+        lines2.push('Use `goop_reference({ name: "resource-name" })` to load content.');
+        lines2.push('Use `goop_reference({ name: "resource-name", section: "Section Name" })` to extract a specific section.');
+        return lines2.join(`
+`);
+      }
+      const name = args.name;
+      let resource = null;
+      let foundType = "reference";
+      if (resourceType === "all" || resourceType === "reference") {
+        resource = ctx.resolver.resolve("reference", name);
+        if (resource)
+          foundType = "reference";
+      }
+      if (!resource && (resourceType === "all" || resourceType === "template")) {
+        resource = ctx.resolver.resolve("template", name);
+        if (resource)
+          foundType = "template";
+      }
+      if (!resource) {
+        const availableRefs = ctx.resolver.resolveAll("reference").map((r) => r.name);
+        const availableTemplates = ctx.resolver.resolveAll("template").map((t) => t.name);
+        return [
+          `Resource "${name}" not found.`,
+          "",
+          "**Available references:**",
+          availableRefs.join(", ") || "(none)",
+          "",
+          "**Available templates:**",
+          availableTemplates.join(", ") || "(none)"
+        ].join(`
+`);
+      }
+      if (args.section) {
+        const sectionContent = getSection(resource, args.section);
+        if (sectionContent) {
+          return [
+            `# ${resource.name} - ${args.section}`,
+            "",
+            `*Extracted from ${foundType}: ${resource.name}*`,
+            "",
+            "---",
+            "",
+            sectionContent
+          ].join(`
+`);
+        } else {
+          return [
+            `Section "${args.section}" not found in ${resource.name}.`,
+            "",
+            "**Available content:**",
+            resource.body.slice(0, 500) + (resource.body.length > 500 ? "..." : "")
+          ].join(`
+`);
+        }
+      }
+      const lines = [
+        `# ${foundType === "reference" ? "Reference" : "Template"}: ${resource.frontmatter.name || resource.name}`,
+        ""
+      ];
+      if (resource.frontmatter.description) {
+        lines.push(`**Description:** ${resource.frontmatter.description}`, "");
+      }
+      if (resource.frontmatter.category) {
+        lines.push(`**Category:** ${resource.frontmatter.category}`, "");
+      }
+      if (resource.frontmatter.version) {
+        lines.push(`**Version:** ${resource.frontmatter.version}`, "");
+      }
+      lines.push("---", "", resource.body);
+      return lines.join(`
+`);
+    }
+  });
+}
+
 // src/tools/slashcommand/index.ts
 function buildDescription(ctx) {
   const commands = ctx.resolver.resolveAll("command");
@@ -28843,6 +29012,7 @@ function createTools(ctx) {
     goop_checkpoint: createGoopCheckpointTool(ctx),
     goop_skill: createGoopSkillTool(ctx),
     goop_delegate: createGoopDelegateTool(ctx),
+    goop_reference: createGoopReferenceTool(ctx),
     goop_setup: createGoopSetupTool(ctx),
     slashcommand: createSlashcommandTool(ctx),
     memory_save: createMemorySaveTool(ctx),
@@ -29550,36 +29720,564 @@ function createMemoryContextBuilder(memoryManager, config3) {
   return new MemoryContextBuilder(memoryManager, config3);
 }
 
+// src/features/enforcement/phase-context.ts
+var DELEGATION_EXAMPLE = `
+Use the task tool for delegation:
+\`\`\`
+task({
+  subagent_type: "goop-executor",  // or other agent type
+  description: "Brief task description",
+  prompt: \`
+    ## TASK
+    [Specific, atomic goal]
+    
+    ## FILES
+    - path/to/file.ts (modify/create)
+    
+    ## REQUIREMENTS
+    [From SPEC.md]
+    
+    ## ACCEPTANCE
+    [How to verify completion]
+  \`
+})
+\`\`\`
+NOTE: Use "task" tool, NOT "delegate" tool for subagent work.
+`.trim();
+var PHASE_ENFORCEMENT = {
+  idle: {
+    phaseName: "IDLE",
+    mustDo: [
+      "Use /goop-plan to start a new feature",
+      "Use /goop-status to check current state"
+    ],
+    mustNotDo: [
+      "Write implementation code without a plan",
+      "Skip the planning phase"
+    ],
+    requiredDocuments: []
+  },
+  plan: {
+    phaseName: "PLAN",
+    mustDo: [
+      "Ask clarifying questions to understand requirements",
+      "Create SPEC.md with must-haves, nice-to-haves, out-of-scope",
+      "Define clear success criteria",
+      "Get user confirmation before proceeding to research/execute",
+      "Call goop_status() to verify current state"
+    ],
+    mustNotDo: [
+      "Write ANY implementation code",
+      "Create source files (only .goopspec/ documents)",
+      "Skip requirement gathering",
+      "Proceed without user confirmation",
+      "Use write/edit tools on src/ files"
+    ],
+    requiredDocuments: ["SPEC.md"]
+  },
+  research: {
+    phaseName: "RESEARCH",
+    mustDo: [
+      "Read SPEC.md to understand requirements",
+      "Research implementation approaches",
+      "Create RESEARCH.md with findings",
+      "Document trade-offs and recommendations",
+      "Search memory for similar past work"
+    ],
+    mustNotDo: [
+      "Write implementation code",
+      "Modify source files",
+      "Skip documenting findings",
+      "Make architectural decisions without documenting"
+    ],
+    requiredDocuments: ["SPEC.md", "RESEARCH.md"]
+  },
+  specify: {
+    phaseName: "SPECIFY",
+    mustDo: [
+      "Create BLUEPRINT.md with wave-based execution plan",
+      "Map all must-haves to specific tasks",
+      "Define verification steps for each task",
+      "Get user confirmation to lock specification",
+      "Call goop_checkpoint() to save state"
+    ],
+    mustNotDo: [
+      "Write implementation code",
+      "Proceed without locked specification",
+      "Skip task decomposition",
+      "Create vague or incomplete tasks"
+    ],
+    requiredDocuments: ["SPEC.md", "BLUEPRINT.md"]
+  },
+  execute: {
+    phaseName: "EXECUTE",
+    mustDo: [
+      "DELEGATE all code work to executor agents using task() tool",
+      "Track progress in CHRONICLE.md",
+      "Follow wave order (complete wave N before wave N+1)",
+      "Verify each task completion before moving on",
+      "Save checkpoints at wave boundaries",
+      "Update ADL.md with any deviations"
+    ],
+    mustNotDo: [
+      "Write code directly - ALWAYS delegate to subagents",
+      "Use 'delegate' tool - use 'task' tool instead",
+      "Skip verification steps",
+      "Ignore test failures",
+      "Modify files outside BLUEPRINT.md scope"
+    ],
+    requiredDocuments: ["SPEC.md", "BLUEPRINT.md", "CHRONICLE.md"],
+    delegationReminder: DELEGATION_EXAMPLE
+  },
+  accept: {
+    phaseName: "ACCEPT",
+    mustDo: [
+      "Verify ALL must-haves from SPEC.md are complete",
+      "Run all tests and ensure they pass",
+      "Check for any deviations in ADL.md",
+      "Get explicit user acceptance",
+      "Save final checkpoint"
+    ],
+    mustNotDo: [
+      "Mark complete without verification",
+      "Skip user confirmation",
+      "Ignore failing tests",
+      "Proceed if must-haves are missing"
+    ],
+    requiredDocuments: ["SPEC.md", "BLUEPRINT.md", "CHRONICLE.md"]
+  }
+};
+function buildPhaseEnforcement(phase, _state) {
+  const rules = PHASE_ENFORCEMENT[phase];
+  if (!rules) {
+    return "";
+  }
+  const lines = [
+    `## PHASE ENFORCEMENT: ${rules.phaseName}`,
+    "",
+    "### MUST DO:"
+  ];
+  for (const item of rules.mustDo) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("", "### MUST NOT DO:");
+  for (const item of rules.mustNotDo) {
+    lines.push(`- ${item}`);
+  }
+  if (rules.requiredDocuments.length > 0) {
+    lines.push("", "### REQUIRED DOCUMENTS:");
+    for (const doc3 of rules.requiredDocuments) {
+      lines.push(`- [ ] ${doc3}`);
+    }
+  }
+  if (rules.delegationReminder) {
+    lines.push("", "### DELEGATION (CRITICAL):", "", rules.delegationReminder);
+  }
+  return lines.join(`
+`);
+}
+function buildStateContext(state) {
+  const workflow = state.workflow;
+  const execution = state.execution;
+  const lines = [
+    "## CURRENT STATE",
+    "",
+    `**Phase:** ${workflow.phase}`,
+    `**Mode:** ${workflow.mode}`,
+    `**Spec Locked:** ${workflow.specLocked ? "Yes" : "No"}`,
+    `**Acceptance Confirmed:** ${workflow.acceptanceConfirmed ? "Yes" : "No"}`
+  ];
+  if (workflow.totalWaves > 0) {
+    lines.push(`**Wave Progress:** ${workflow.currentWave}/${workflow.totalWaves}`);
+  }
+  if (execution.activeCheckpointId) {
+    lines.push(`**Active Checkpoint:** ${execution.activeCheckpointId}`);
+  }
+  if (execution.pendingTasks.length > 0) {
+    lines.push(`**Pending Tasks:** ${execution.pendingTasks.length}`);
+  }
+  return lines.join(`
+`);
+}
+function buildEnforcementContext(state) {
+  const stateContext = buildStateContext(state);
+  const phaseEnforcement = buildPhaseEnforcement(state.workflow.phase, state);
+  if (!phaseEnforcement) {
+    return stateContext;
+  }
+  return `${stateContext}
+
+${phaseEnforcement}`;
+}
+// src/features/enforcement/scaffolder.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
+
+// src/shared/template-engine.ts
+function renderTemplate(template, context) {
+  let result = template;
+  result = result.replace(/\{\{([^#^/][^}]*)\}\}/g, (match, key) => {
+    const trimmedKey = key.trim();
+    const value = getNestedValue(context, trimmedKey);
+    if (value === undefined || value === null) {
+      return match;
+    }
+    if (Array.isArray(value)) {
+      return value.join(", ");
+    }
+    return String(value);
+  });
+  result = result.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_match, key, content) => {
+    const value = getNestedValue(context, key);
+    if (!value) {
+      return "";
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => {
+        if (typeof item === "object") {
+          return renderTemplate(content, item);
+        }
+        return content.replace(/\{\{\.\}\}/g, String(item));
+      }).join("");
+    }
+    return renderTemplate(content, context);
+  });
+  result = result.replace(/\{\{\^(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (_match, key, content) => {
+    const value = getNestedValue(context, key);
+    if (!value || Array.isArray(value) && value.length === 0) {
+      return renderTemplate(content, context);
+    }
+    return "";
+  });
+  return result;
+}
+function getNestedValue(context, path2) {
+  const parts = path2.split(".");
+  let current = context;
+  for (const part of parts) {
+    if (current === null || current === undefined) {
+      return;
+    }
+    if (typeof current === "object") {
+      current = current[part];
+    } else {
+      return;
+    }
+  }
+  return current;
+}
+function createDefaultContext(projectName, phaseName, additionalContext = {}) {
+  const now = new Date;
+  return {
+    project_name: projectName,
+    phase_name: phaseName,
+    version: "1.0.0",
+    created_date: now.toISOString().split("T")[0],
+    updated_date: now.toISOString().split("T")[0],
+    status: "DRAFT",
+    mode: "standard",
+    vision: "[Vision to be defined]",
+    why: "[Motivation to be defined]",
+    goal: "[Goal to be defined]",
+    approach: "[Approach to be defined]",
+    must_haves: [],
+    nice_to_haves: [],
+    out_of_scope: [],
+    acceptance_criteria: [],
+    always: [],
+    ask_first: [],
+    never: [],
+    runtime: "Bun",
+    language: "TypeScript",
+    framework: "[Framework]",
+    database: "[Database]",
+    testing: "bun:test",
+    file_naming: "kebab-case",
+    component_naming: "PascalCase",
+    function_naming: "camelCase",
+    commit_format: "conventional",
+    ...additionalContext
+  };
+}
+
+// src/features/enforcement/scaffolder.ts
+var DOCUMENT_CONFIGS = {
+  spec: {
+    templateName: "spec.md",
+    fileName: "SPEC.md",
+    requiredInPhases: ["plan", "research", "specify", "execute", "accept"]
+  },
+  blueprint: {
+    templateName: "blueprint.md",
+    fileName: "BLUEPRINT.md",
+    requiredInPhases: ["specify", "execute", "accept"]
+  },
+  chronicle: {
+    templateName: "chronicle.md",
+    fileName: "CHRONICLE.md",
+    requiredInPhases: ["plan", "research", "specify", "execute", "accept"]
+  },
+  research: {
+    templateName: "research.md",
+    fileName: "RESEARCH.md",
+    requiredInPhases: ["research", "specify"]
+  }
+};
+function getTemplatesDir(ctx) {
+  const projectTemplates = join8(ctx.input.directory, "templates");
+  if (existsSync10(projectTemplates)) {
+    return projectTemplates;
+  }
+  const resolver = ctx.resolver;
+  const templateDir = resolver.getDirectory("template");
+  if (templateDir && existsSync10(templateDir)) {
+    return templateDir;
+  }
+  const devTemplates = join8(dirname4(import.meta.dir), "..", "..", "templates");
+  if (existsSync10(devTemplates)) {
+    return devTemplates;
+  }
+  throw new Error("Templates directory not found");
+}
+function loadTemplate(ctx, templateName) {
+  try {
+    const templatesDir = getTemplatesDir(ctx);
+    const templatePath = join8(templatesDir, templateName);
+    if (!existsSync10(templatePath)) {
+      log(`Template not found: ${templatePath}`);
+      return null;
+    }
+    return readFileSync8(templatePath, "utf-8");
+  } catch (error92) {
+    logError(`Failed to load template: ${templateName}`, error92);
+    return null;
+  }
+}
+async function scaffoldPhaseDocuments(ctx, phaseName, phase, additionalContext = {}) {
+  const result = {
+    success: true,
+    phaseDir: "",
+    documentsCreated: [],
+    documentsSkipped: [],
+    errors: []
+  };
+  try {
+    const goopspecDir = getProjectGoopspecDir(ctx.input.directory);
+    const phaseDir = join8(goopspecDir, "phases", sanitizePhaseName2(phaseName));
+    result.phaseDir = phaseDir;
+    if (!existsSync10(phaseDir)) {
+      mkdirSync5(phaseDir, { recursive: true });
+      log(`Created phase directory: ${phaseDir}`);
+    }
+    const projectName = ctx.config.projectName || ctx.input.project.name || "unnamed";
+    const templateContext = createDefaultContext(projectName, phaseName, {
+      current_phase: phase,
+      ...additionalContext
+    });
+    for (const [docType, config3] of Object.entries(DOCUMENT_CONFIGS)) {
+      const docPath = join8(phaseDir, config3.fileName);
+      if (existsSync10(docPath)) {
+        result.documentsSkipped.push(config3.fileName);
+        log(`Document already exists, skipping: ${config3.fileName}`);
+        continue;
+      }
+      if (!config3.requiredInPhases.includes(phase)) {
+        continue;
+      }
+      const template = loadTemplate(ctx, config3.templateName);
+      if (!template) {
+        const minimalContent = createMinimalDocument(docType, templateContext);
+        writeFileSync4(docPath, minimalContent, "utf-8");
+        result.documentsCreated.push(config3.fileName);
+        log(`Created minimal document (no template): ${config3.fileName}`);
+        continue;
+      }
+      const content = renderTemplate(template, templateContext);
+      writeFileSync4(docPath, content, "utf-8");
+      result.documentsCreated.push(config3.fileName);
+      log(`Created document: ${config3.fileName}`);
+    }
+    return result;
+  } catch (error92) {
+    result.success = false;
+    result.errors.push(error92 instanceof Error ? error92.message : String(error92));
+    logError("Failed to scaffold phase documents", error92);
+    return result;
+  }
+}
+function sanitizePhaseName2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function createMinimalDocument(docType, context) {
+  const projectName = context.project_name || "Project";
+  const phaseName = context.phase_name || "Phase";
+  const date9 = context.created_date || new Date().toISOString().split("T")[0];
+  switch (docType) {
+    case "spec":
+      return `# SPEC: ${projectName}
+
+**Version:** 1.0.0
+**Created:** ${date9}
+**Status:** DRAFT
+
+---
+
+## Vision
+
+[Describe what you're building and why]
+
+---
+
+## Must-Haves
+
+- [ ] [Requirement 1]
+- [ ] [Requirement 2]
+
+---
+
+## Out of Scope
+
+- [Item 1]
+
+---
+
+## Success Criteria
+
+1. [Criterion 1]
+2. [Criterion 2]
+
+---
+
+*GoopSpec v0.1.0*
+`;
+    case "blueprint":
+      return `# BLUEPRINT: ${projectName}
+
+**Spec Version:** 1.0.0
+**Created:** ${date9}
+**Mode:** standard
+
+---
+
+## Overview
+
+**Goal:** [Define the goal]
+
+**Waves:** 0
+**Tasks:** 0
+
+---
+
+## Waves
+
+[Define waves and tasks here]
+
+---
+
+*GoopSpec v0.1.0*
+`;
+    case "chronicle":
+      return `# CHRONICLE: ${projectName}
+
+**Last Updated:** ${date9}
+**Current Phase:** ${phaseName}
+
+---
+
+## Status
+
+**Position:** Starting
+
+| Metric | Value |
+|--------|-------|
+| Waves Completed | 0/0 |
+| Tasks Done | 0 |
+
+---
+
+## Recent Activity
+
+[Activity will be logged here]
+
+---
+
+*GoopSpec v0.1.0*
+`;
+    case "research":
+      return `# RESEARCH: ${projectName}
+
+**Created:** ${date9}
+**Phase:** ${phaseName}
+
+---
+
+## Research Goals
+
+[What are you researching?]
+
+---
+
+## Findings
+
+[Document findings here]
+
+---
+
+## Recommendations
+
+[Recommendations based on research]
+
+---
+
+*GoopSpec v0.1.0*
+`;
+    default:
+      return `# ${String(docType).toUpperCase()}
+
+Created: ${date9}
+`;
+  }
+}
+// src/features/enforcement/validators.ts
+var EXCLUDED_EXTENSIONS = new Set([".md", ".json"]);
 // src/hooks/system-transform.ts
 function createSystemTransformHook(ctx) {
   return async (input, output) => {
-    if (!ctx.memoryManager || ctx.config.memory?.injection?.enabled === false) {
-      return output;
-    }
     log("System transform hook triggered", {
       agent: input.agent,
       sessionID: input.sessionID
     });
     try {
-      const builder = createMemoryContextBuilder(ctx.memoryManager, {
-        budgetTokens: ctx.config.memory?.injection?.budgetTokens ?? 800,
-        format: ctx.config.memory?.injection?.format ?? "structured",
-        priorityTypes: ctx.config.memory?.injection?.priorityTypes ?? ["decision", "observation", "todo"],
-        includeDecisions: true,
-        includeRecentActivity: true
-      });
-      const currentPhase = ctx.stateManager.getState().workflow.phase;
-      let memoryContext;
-      if (currentPhase) {
-        memoryContext = await builder.buildPhaseContext(currentPhase);
-      } else {
-        memoryContext = await builder.buildRecentContext(10);
+      const state = ctx.stateManager.getState();
+      const enforcementContext = buildEnforcementContext(state);
+      let memoryContext = "";
+      if (ctx.memoryManager && ctx.config.memory?.injection?.enabled !== false) {
+        const builder = createMemoryContextBuilder(ctx.memoryManager, {
+          budgetTokens: ctx.config.memory?.injection?.budgetTokens ?? 800,
+          format: ctx.config.memory?.injection?.format ?? "structured",
+          priorityTypes: ctx.config.memory?.injection?.priorityTypes ?? ["decision", "observation", "todo"],
+          includeDecisions: true,
+          includeRecentActivity: true
+        });
+        const currentPhase = state.workflow.phase;
+        if (currentPhase) {
+          memoryContext = await builder.buildPhaseContext(currentPhase);
+        } else {
+          memoryContext = await builder.buildRecentContext(10);
+        }
       }
-      if (!memoryContext || memoryContext.trim().length === 0) {
-        log("No memory context to inject");
+      if (!enforcementContext && (!memoryContext || memoryContext.trim().length === 0)) {
+        log("No enforcement or memory context to inject");
         return output;
       }
-      const enhancedSystem = `${output.system}
+      let enhancedSystem = output.system;
+      if (enforcementContext.trim().length > 0) {
+        enhancedSystem = `${enhancedSystem}
+
+${enforcementContext}`;
+      }
+      if (memoryContext.trim().length > 0) {
+        enhancedSystem = `${enhancedSystem}
 
 ## Persistent Memory Context
 
@@ -29588,28 +30286,159 @@ The following memories are relevant to this session. Use them to maintain contin
 ${memoryContext}
 
 Use the memory tools (memory_save, memory_search, memory_note, memory_decision) to store and retrieve information for future sessions.`;
-      log("Memory context injected", {
+      }
+      log("System context injected", {
         originalLength: output.system.length,
-        contextLength: memoryContext.length,
+        enforcementLength: enforcementContext.length,
+        memoryLength: memoryContext.length,
         enhancedLength: enhancedSystem.length
       });
       return {
         system: enhancedSystem
       };
     } catch (error92) {
-      logError("Failed to inject memory context", error92);
+      logError("Failed to inject system context", error92);
       return output;
     }
   };
 }
 
+// src/hooks/command-processor.ts
+import { join as join9 } from "path";
+var COMMAND_PHASES = {
+  "goop-plan": "plan",
+  "goop-research": "research",
+  "goop-specify": "specify",
+  "goop-execute": "execute",
+  "goop-accept": "accept"
+};
+function createCommandProcessor(ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (input.tool !== "slashcommand") {
+        return;
+      }
+      const commandText = getCommandText(output);
+      const parsed = commandText ? parseCommandText(commandText) : null;
+      if (!parsed) {
+        return;
+      }
+      const phase = COMMAND_PHASES[parsed.name];
+      if (!phase) {
+        return;
+      }
+      const transitioned = ctx.stateManager.transitionPhase(phase);
+      let scaffoldResult = null;
+      let phaseName = "";
+      if (parsed.name === "goop-plan") {
+        phaseName = parsed.args || "plan";
+        scaffoldResult = await scaffoldPhaseDocuments(ctx, phaseName, "plan");
+      }
+      if (!transitioned) {
+        logError(`Command processor failed to transition to ${phase}`);
+      }
+      if (scaffoldResult && !scaffoldResult.success) {
+        logError("Command processor failed to scaffold phase documents", scaffoldResult.errors);
+      }
+      const files = scaffoldResult ? scaffoldResult.documentsCreated.map((doc3) => join9(scaffoldResult.phaseDir, doc3)) : undefined;
+      const actionParts = [`Transitioned to ${phase}`];
+      if (scaffoldResult) {
+        const scaffoldStatus = scaffoldResult.success ? "scaffolded" : "failed to scaffold";
+        const docCount = scaffoldResult.documentsCreated.length;
+        const namePart = phaseName ? ` for phase "${phaseName}"` : "";
+        actionParts.push(`${scaffoldStatus} ${docCount} documents${namePart}`);
+        if (!scaffoldResult.success && scaffoldResult.errors.length > 0) {
+          actionParts.push(`errors: ${scaffoldResult.errors.join("; ")}`);
+        }
+      }
+      const adlEntry = {
+        timestamp: new Date().toISOString(),
+        type: "observation",
+        description: `Slash command "/${parsed.name}" processed`,
+        action: transitioned ? actionParts.join("; ") : `Transition to ${phase} rejected`,
+        files
+      };
+      ctx.stateManager.appendADL(adlEntry);
+      log("Command processor handled slash command", {
+        command: parsed.name,
+        phase,
+        transitioned,
+        phaseName: phaseName || undefined
+      });
+    }
+  };
+}
+function getCommandText(output) {
+  const metadataCommand = extractCommandFromMetadata(output.metadata);
+  if (metadataCommand) {
+    return metadataCommand;
+  }
+  return extractCommandFromOutput(output.output);
+}
+function extractCommandFromMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object") {
+    return null;
+  }
+  const record3 = metadata;
+  if (typeof record3.command === "string") {
+    return record3.command;
+  }
+  const args = record3.args;
+  if (args && typeof args === "object") {
+    const argsRecord = args;
+    if (typeof argsRecord.command === "string") {
+      return argsRecord.command;
+    }
+  }
+  return null;
+}
+function extractCommandFromOutput(output) {
+  if (!output) {
+    return null;
+  }
+  const match = output.match(/^#\s*\/([^\s]+)\s+Command/m);
+  if (!match) {
+    return null;
+  }
+  return match[1];
+}
+function parseCommandText(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const normalized = trimmed.replace(/^\//, "");
+  const [name, ...rest] = normalized.split(/\s+/);
+  if (!name) {
+    return null;
+  }
+  return {
+    name: name.toLowerCase(),
+    args: rest.join(" ").trim()
+  };
+}
+
 // src/hooks/index.ts
 function createHooks(ctx) {
+  const toolLifecycleHooks = createToolLifecycleHooks(ctx);
+  const commandProcessorHooks = createCommandProcessor(ctx);
+  const toolExecuteAfterHooks = [
+    toolLifecycleHooks["tool.execute.after"],
+    commandProcessorHooks["tool.execute.after"]
+  ].filter((hook) => Boolean(hook));
   const hooks = {
     event: createEventHandler(ctx),
     "chat.message": createChatMessageHook(ctx),
-    ...createToolLifecycleHooks(ctx)
+    ...toolLifecycleHooks,
+    ...commandProcessorHooks
   };
+  if (toolExecuteAfterHooks.length > 0) {
+    hooks["tool.execute.after"] = async (input, output) => {
+      for (const hook of toolExecuteAfterHooks) {
+        await hook(input, output);
+      }
+    };
+  }
   if (ctx.memoryManager && ctx.config.memory?.injection?.enabled !== false) {
     hooks["experimental.chat.system.transform"] = createSystemTransformHook(ctx);
   }