@lucapimenta/copy-chief-black 1.0.0

package/framework/hooks/stop-copy-validation.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_copy_output_validator = require("../.aios-core/copy-chief/gates/copy-output-validator");
+function allow() {
+  console.log(JSON.stringify({}));
+  process.exit(0);
+}
+function block(reason, logLabel) {
+  const output = { decision: "block", reason };
+  console.error(`[STOP-GATE] ${logLabel}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+function main() {
+  try {
+    let stdin = "";
+    try {
+      stdin = (0, import_fs.readFileSync)(0, "utf8");
+    } catch {
+      allow();
+      return;
+    }
+    let input;
+    try {
+      input = JSON.parse(stdin || "{}");
+    } catch {
+      allow();
+      return;
+    }
+    if (input.stop_hook_active) {
+      allow();
+      return;
+    }
+    const result = (0, import_copy_output_validator.validateCopyOutput)(input.transcript_path);
+    if (result.ok) {
+      allow();
+      return;
+    }
+    if (result.reason === "terminal_copy") {
+      block(
+        (0, import_copy_output_validator.buildTerminalCopyMessage)(result.filesWritten),
+        `Bloqueado: Copy no terminal. Arquivos escritos: ${result.filesWritten.length}`
+      );
+      return;
+    }
+    if (result.reason === "missing_methodology") {
+      block(
+        (0, import_copy_output_validator.buildMissingMethodologyMessage)(result.vitalsCount, result.methodologyCount, result.totalFiles),
+        `Bloqueado: Copy sem metodologia. Vitais: ${result.vitalsCount}, Metodologia: ${result.methodologyCount}`
+      );
+      return;
+    }
+    allow();
+  } catch (error) {
+    try {
+      const logDir = `${process.env.HOME}/.claude/logs`;
+      try {
+        (0, import_fs.mkdirSync)(logDir, { recursive: true });
+      } catch {
+      }
+      (0, import_fs.appendFileSync)(
+        `${logDir}/hook-errors.log`,
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] stop-copy-validation: ${error}
+`
+      );
+    } catch {
+    }
+    allow();
+  }
+}
+main();

package/framework/hooks/stop-copy-validation.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env bun
+// ~/.claude/hooks/stop-copy-validation.ts — Stop Hook (thin wrapper)
+// Blocks copy in terminal + validates methodology was consulted.
+//
+// Business logic: ~/.claude/.aios-core/copy-chief/gates/copy-output-validator.ts
+// v2.0 (2026-02-01) | Refactored: 2026-03-02
+
+import { readFileSync, mkdirSync, appendFileSync } from 'fs';
+import {
+  validateCopyOutput,
+  buildTerminalCopyMessage,
+  buildMissingMethodologyMessage,
+} from '../.aios-core/copy-chief/gates/copy-output-validator';
+
+interface StopInput {
+  session_id: string;
+  transcript_path: string;
+  stop_hook_active: boolean;
+  cwd: string;
+}
+
+interface StopOutput {
+  decision?: 'block';
+  reason?: string;
+}
+
+function allow(): void {
+  console.log(JSON.stringify({}));
+  process.exit(0);
+}
+
+function block(reason: string, logLabel: string): void {
+  const output: StopOutput = { decision: 'block', reason };
+  console.error(`[STOP-GATE] ${logLabel}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+function main(): void {
+  try {
+    let stdin = '';
+    try { stdin = readFileSync(0, 'utf8'); } catch { allow(); return; }
+
+    let input: StopInput;
+    try { input = JSON.parse(stdin || '{}'); } catch { allow(); return; }
+
+    if (input.stop_hook_active) { allow(); return; }
+
+    const result = validateCopyOutput(input.transcript_path);
+
+    if (result.ok) { allow(); return; }
+
+    if (result.reason === 'terminal_copy') {
+      block(
+        buildTerminalCopyMessage(result.filesWritten),
+        `Bloqueado: Copy no terminal. Arquivos escritos: ${result.filesWritten.length}`
+      );
+      return;
+    }
+
+    if (result.reason === 'missing_methodology') {
+      block(
+        buildMissingMethodologyMessage(result.vitalsCount, result.methodologyCount, result.totalFiles),
+        `Bloqueado: Copy sem metodologia. Vitais: ${result.vitalsCount}, Metodologia: ${result.methodologyCount}`
+      );
+      return;
+    }
+
+    allow();
+  } catch (error) {
+    // FAIL-OPEN: never show error to user
+    try {
+      const logDir = `${process.env.HOME}/.claude/logs`;
+      try { mkdirSync(logDir, { recursive: true }); } catch {}
+      appendFileSync(`${logDir}/hook-errors.log`,
+        `[${new Date().toISOString()}] stop-copy-validation: ${error}\n`);
+    } catch {}
+    allow();
+  }
+}
+
+main();

package/framework/hooks/story-required-gate.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_path = require("path");
+const STORY_REQUIRED_PATTERNS = [
+  /production\//i
+];
+const EXEMPT_PATTERNS = [
+  /\.claude\//i,
+  /scripts\//i,
+  /hooks\//i,
+  /templates\//i,
+  /\.synapse\//i,
+  /squads\//i,
+  /research\//i,
+  /briefings?\//i,
+  /swipes\//i,
+  /reviews?\//i,
+  /\.json$/i,
+  /\.yaml$/i,
+  /\.yml$/i,
+  /\.ts$/i,
+  /\.js$/i,
+  /\.sh$/i,
+  /CONTEXT\.md$/i,
+  /CLAUDE\.md$/i,
+  /README/i,
+  /helix-state/i,
+  /mecanismo-unico/i,
+  /project_state/i,
+  /task_plan/i,
+  /progress\.md/i,
+  /findings\.md/i
+];
+function resolveOfferPath(filePath) {
+  const ecosystemRoot = (0, import_path.join)(process.env.HOME || "/root", "copywriting-ecosystem");
+  let dir = filePath;
+  if (!dir.endsWith("/")) {
+    dir = (0, import_path.join)(dir, "..");
+  }
+  for (let i = 0; i < 6; i++) {
+    if (dir === "/" || dir === ecosystemRoot || dir === process.env.HOME) break;
+    const aiosDir = (0, import_path.join)(dir, ".aios");
+    const helixState = (0, import_path.join)(dir, "helix-state.yaml");
+    if ((0, import_fs.existsSync)(aiosDir) || (0, import_fs.existsSync)(helixState)) {
+      return dir;
+    }
+    dir = (0, import_path.join)(dir, "..");
+  }
+  return null;
+}
+function hasActiveStory(filePath) {
+  try {
+    const offerPath = resolveOfferPath(filePath);
+    if (offerPath) {
+      const storyFile = (0, import_path.join)(offerPath, ".aios", "story.yaml");
+      if ((0, import_fs.existsSync)(storyFile)) {
+        const content = (0, import_fs.readFileSync)(storyFile, "utf-8");
+        const statusMatch = content.match(/^status:\s*['"]?(\w+)['"]?/m);
+        const status = statusMatch ? statusMatch[1] : null;
+        if (status === "open") {
+          const phaseMatch = content.match(/^phase:\s*['"]?([^\s'"]+)['"]?/m);
+          const phase = phaseMatch ? phaseMatch[1] : "unknown";
+          return { active: true, storyName: `${offerPath.split("/").slice(-2).join("/")}:${phase}`, offerPath };
+        }
+        return { active: false, offerPath };
+      }
+      return { active: false, offerPath };
+    }
+    const ecosystemRoot = (0, import_path.join)(process.env.HOME || "/root", "copywriting-ecosystem");
+    if (!(0, import_fs.existsSync)(ecosystemRoot)) return { active: false };
+    const niches = (0, import_fs.readdirSync)(ecosystemRoot).filter((n) => {
+      if (n.startsWith(".") || n === "squads" || n === "scripts" || n === "site") return false;
+      try {
+        return (0, import_fs.readdirSync)((0, import_path.join)(ecosystemRoot, n)).length > 0;
+      } catch {
+        return false;
+      }
+    });
+    for (const niche of niches) {
+      try {
+        const offers = (0, import_fs.readdirSync)((0, import_path.join)(ecosystemRoot, niche));
+        for (const offer of offers) {
+          const storyFile = (0, import_path.join)(ecosystemRoot, niche, offer, ".aios", "story.yaml");
+          if (!(0, import_fs.existsSync)(storyFile)) continue;
+          const content = (0, import_fs.readFileSync)(storyFile, "utf-8");
+          const statusMatch = content.match(/^status:\s*['"]?(\w+)['"]?/m);
+          if (statusMatch && statusMatch[1] === "open") {
+            return { active: true, storyName: `${niche}/${offer}` };
+          }
+        }
+      } catch {
+      }
+    }
+    return { active: false };
+  } catch {
+    return { active: true };
+  }
+}
+function main() {
+  try {
+    const stdin = (0, import_fs.readFileSync)(0, "utf8");
+    const input = JSON.parse(stdin);
+    const toolName = input.tool_name;
+    if (!["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(toolName)) {
+      allow();
+      return;
+    }
+    const filePath = input.tool_input?.file_path || input.tool_input?.path || input.tool_input?.notebook_path || "";
+    if (!filePath) {
+      allow();
+      return;
+    }
+    if (EXEMPT_PATTERNS.some((p) => p.test(filePath))) {
+      allow();
+      return;
+    }
+    const requiresStory = STORY_REQUIRED_PATTERNS.some((p) => p.test(filePath));
+    if (!requiresStory) {
+      allow();
+      return;
+    }
+    const { active, storyName } = hasActiveStory(filePath);
+    if (active) {
+      console.error(`[STORY-GATE] OK: Active story "${storyName}" \u2014 write allowed to ${filePath}`);
+      allow();
+      return;
+    }
+    block(filePath);
+  } catch (error) {
+    console.error(`[STORY-GATE] Error: ${error}`);
+    allow();
+  }
+}
+function allow() {
+  console.log(JSON.stringify({}));
+  process.exit(0);
+}
+function block(filePath) {
+  const offerHint = resolveOfferPath(filePath);
+  const storyLocation = offerHint ? `${offerHint}/.aios/story.yaml` : "{offer}/.aios/story.yaml";
+  const output = {
+    decision: "block",
+    reason: `BLOQUEADO \u2014 Nenhuma story aberta para esta oferta
+
+**Arquivo:** ${filePath}
+**Principio:** "Nenhum codigo/copy e produzido sem story ativa"
+**Fonte:** U-23 Story-Driven Production
+
+Writes em production/ requerem uma story com status: open em:
+  ${storyLocation}
+
+**ACAO:**
+1. Crie a story com StoryManager.createStory(offerPath, phase, workflowDef)
+   Ou manualmente: escreva ${storyLocation} com status: open
+2. A story define os acceptance_criteria do que deve ser entregue
+3. Ao concluir, feche com StoryManager.closeStory(offerPath)
+
+Exemplo de story.yaml:
+\`\`\`yaml
+status: open
+phase: production
+created_at: "${(/* @__PURE__ */ new Date()).toISOString()}"
+acceptance_criteria:
+  - id: vsl-draft
+    description: "echo produces production/vsl/vsl-draft.md"
+    expected_outputs: ["production/vsl/vsl-draft.md"]
+completed_criteria: []
+\`\`\``
+  };
+  console.error(`[STORY-GATE] BLOCKED: No active story for production write to ${filePath}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+main();

package/framework/hooks/story-required-gate.ts

@@ -0,0 +1,259 @@
+#!/usr/bin/env bun
+// ~/.claude/hooks/story-required-gate.ts
+// Story Required Gate — Gap Closure #1
+// v2.0 (2026-03-03) — U-23: Story-Driven Production
+//
+// Constitution principle: "Nenhum codigo/copy e produzido sem story ativa"
+// Story location: {offer}/.aios/story.yaml (status: open | closed)
+//
+// BLOCKS: Write/Edit to production/* if no open story exists at offer level
+// ALLOWS: research/, briefings/, .claude/, scripts/, config files, etc.
+
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface PreToolUseInput {
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+}
+
+interface PreToolUseOutput {
+  decision?: 'block' | 'allow';
+  reason?: string;
+}
+
+// ─── Paths that REQUIRE an active story ──────────────────────────────────────
+
+const STORY_REQUIRED_PATTERNS = [
+  /production\//i,
+];
+
+// ─── Paths that are EXEMPT (never need a story) ─────────────────────────────
+
+const EXEMPT_PATTERNS = [
+  /\.claude\//i,
+  /scripts\//i,
+  /hooks\//i,
+  /templates\//i,
+  /\.synapse\//i,
+  /squads\//i,
+  /research\//i,
+  /briefings?\//i,
+  /swipes\//i,
+  /reviews?\//i,
+  /\.json$/i,
+  /\.yaml$/i,
+  /\.yml$/i,
+  /\.ts$/i,
+  /\.js$/i,
+  /\.sh$/i,
+  /CONTEXT\.md$/i,
+  /CLAUDE\.md$/i,
+  /README/i,
+  /helix-state/i,
+  /mecanismo-unico/i,
+  /project_state/i,
+  /task_plan/i,
+  /progress\.md/i,
+  /findings\.md/i,
+];
+
+// ─── Story Detection ─────────────────────────────────────────────────────────
+
+/**
+ * Resolve the offer path from a production file path.
+ * Walks up from the file path to find the directory containing .aios/story.yaml.
+ * Production paths look like: {ecosystemRoot}/{niche}/{offer}/production/...
+ * We look for the first ancestor that has a .aios/ dir or helix-state.yaml.
+ */
+function resolveOfferPath(filePath: string): string | null {
+  const ecosystemRoot = join(process.env.HOME || '/root', 'copywriting-ecosystem');
+
+  // Strip trailing segments until we find the offer root
+  let dir = filePath;
+  // Remove the filename if it looks like a file (has extension or no trailing slash)
+  if (!dir.endsWith('/')) {
+    dir = join(dir, '..'); // go up one level from the file
+  }
+
+  // Walk up at most 6 levels looking for an .aios dir or helix-state.yaml
+  for (let i = 0; i < 6; i++) {
+    if (dir === '/' || dir === ecosystemRoot || dir === process.env.HOME) break;
+
+    const aiosDir = join(dir, '.aios');
+    const helixState = join(dir, 'helix-state.yaml');
+
+    if (existsSync(aiosDir) || existsSync(helixState)) {
+      return dir;
+    }
+
+    dir = join(dir, '..');
+  }
+
+  return null;
+}
+
+/**
+ * Check if there's an open story for the offer that owns this file path.
+ * Reads from {offer}/.aios/story.yaml (status: 'open' = active).
+ * Falls back to scanning ecosystem for any open story if offer can't be resolved.
+ */
+function hasActiveStory(filePath: string): { active: boolean; storyName?: string; offerPath?: string } {
+  try {
+    // First: try to resolve story from the specific offer this file belongs to
+    const offerPath = resolveOfferPath(filePath);
+
+    if (offerPath) {
+      const storyFile = join(offerPath, '.aios', 'story.yaml');
+      if (existsSync(storyFile)) {
+        const content = readFileSync(storyFile, 'utf-8');
+        // Parse status field from YAML (simple line-based read, avoid full YAML parse dependency)
+        const statusMatch = content.match(/^status:\s*['"]?(\w+)['"]?/m);
+        const status = statusMatch ? statusMatch[1] : null;
+        if (status === 'open') {
+          const phaseMatch = content.match(/^phase:\s*['"]?([^\s'"]+)['"]?/m);
+          const phase = phaseMatch ? phaseMatch[1] : 'unknown';
+          return { active: true, storyName: `${offerPath.split('/').slice(-2).join('/')}:${phase}`, offerPath };
+        }
+        // Story exists but is closed — block
+        return { active: false, offerPath };
+      }
+      // No story.yaml at offer level — no story exists
+      return { active: false, offerPath };
+    }
+
+    // Fallback: scan all offers in ecosystem for an open story
+    const ecosystemRoot = join(process.env.HOME || '/root', 'copywriting-ecosystem');
+    if (!existsSync(ecosystemRoot)) return { active: false };
+
+    const niches = readdirSync(ecosystemRoot).filter(n => {
+      if (n.startsWith('.') || n === 'squads' || n === 'scripts' || n === 'site') return false;
+      try {
+        return readdirSync(join(ecosystemRoot, n)).length > 0;
+      } catch { return false; }
+    });
+
+    for (const niche of niches) {
+      try {
+        const offers = readdirSync(join(ecosystemRoot, niche));
+        for (const offer of offers) {
+          const storyFile = join(ecosystemRoot, niche, offer, '.aios', 'story.yaml');
+          if (!existsSync(storyFile)) continue;
+          const content = readFileSync(storyFile, 'utf-8');
+          const statusMatch = content.match(/^status:\s*['"]?(\w+)['"]?/m);
+          if (statusMatch && statusMatch[1] === 'open') {
+            return { active: true, storyName: `${niche}/${offer}` };
+          }
+        }
+      } catch { /* skip unreadable */ }
+    }
+
+    return { active: false };
+  } catch {
+    // If we can't read stories, fail-open (don't block)
+    return { active: true };
+  }
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+function main(): void {
+  try {
+    const stdin = readFileSync(0, 'utf8');
+    const input: PreToolUseInput = JSON.parse(stdin);
+
+    const toolName = input.tool_name;
+
+    // Only check Write and Edit
+    if (!['Write', 'Edit', 'MultiEdit', 'NotebookEdit'].includes(toolName)) {
+      allow();
+      return;
+    }
+
+    // Extract file path
+    const filePath = (input.tool_input?.file_path || input.tool_input?.path || input.tool_input?.notebook_path || '') as string;
+    if (!filePath) {
+      allow();
+      return;
+    }
+
+    // Check if path is exempt
+    if (EXEMPT_PATTERNS.some(p => p.test(filePath))) {
+      allow();
+      return;
+    }
+
+    // Check if path requires a story
+    const requiresStory = STORY_REQUIRED_PATTERNS.some(p => p.test(filePath));
+    if (!requiresStory) {
+      allow();
+      return;
+    }
+
+    // Check for active story in {offer}/.aios/story.yaml
+    const { active, storyName } = hasActiveStory(filePath);
+
+    if (active) {
+      console.error(`[STORY-GATE] OK: Active story "${storyName}" — write allowed to ${filePath}`);
+      allow();
+      return;
+    }
+
+    // No open story — hard block (U-23: story is required for production writes)
+    block(filePath);
+
+  } catch (error) {
+    console.error(`[STORY-GATE] Error: ${error}`);
+    allow(); // Fail-open
+  }
+}
+
+function allow(): void {
+  console.log(JSON.stringify({}));
+  process.exit(0);
+}
+
+function block(filePath: string): void {
+  const offerHint = resolveOfferPath(filePath);
+  const storyLocation = offerHint
+    ? `${offerHint}/.aios/story.yaml`
+    : '{offer}/.aios/story.yaml';
+
+  const output: PreToolUseOutput = {
+    decision: 'block',
+    reason: `BLOQUEADO — Nenhuma story aberta para esta oferta
+
+**Arquivo:** ${filePath}
+**Principio:** "Nenhum codigo/copy e produzido sem story ativa"
+**Fonte:** U-23 Story-Driven Production
+
+Writes em production/ requerem uma story com status: open em:
+  ${storyLocation}
+
+**ACAO:**
+1. Crie a story com StoryManager.createStory(offerPath, phase, workflowDef)
+   Ou manualmente: escreva ${storyLocation} com status: open
+2. A story define os acceptance_criteria do que deve ser entregue
+3. Ao concluir, feche com StoryManager.closeStory(offerPath)
+
+Exemplo de story.yaml:
+\`\`\`yaml
+status: open
+phase: production
+created_at: "${new Date().toISOString()}"
+acceptance_criteria:
+  - id: vsl-draft
+    description: "echo produces production/vsl/vsl-draft.md"
+    expected_outputs: ["production/vsl/vsl-draft.md"]
+completed_criteria: []
+\`\`\``,
+  };
+
+  console.error(`[STORY-GATE] BLOCKED: No active story for production write to ${filePath}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+main();

package/framework/hooks/subagent-start-log.cjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+// subagent-start-log.cjs - Log subagent context when spawning
+// Hook: SubagentStart — v5.3
+
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+
+let inputJson = '{}';
+try {
+  inputJson = fs.readFileSync(0, 'utf8');
+} catch (e) {
+  inputJson = '{}';
+}
+
+let parsed = {};
+try {
+  parsed = JSON.parse(inputJson);
+} catch (e) {
+  parsed = {};
+}
+
+const agentId = parsed.agent_id || 'unknown';
+const agentType = parsed.agent_type || 'unknown';
+const cwd = parsed.cwd || 'unknown';
+
+// Log to file
+const logFile = path.join(HOME, '.claude', 'logs', 'subagents.log');
+fs.mkdirSync(path.dirname(logFile), { recursive: true });
+
+const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+fs.appendFileSync(logFile, `[${timestamp}] START | Agent: ${agentType} | ID: ${agentId} | CWD: ${cwd}\n`);
+
+// Always allow
+process.exit(0);

package/framework/hooks/subagent-start-log.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+# Hook: SubagentStart
+# Purpose: Log subagent context when spawning
+# v5.3 - FASE 4 Hook Avançado
+
+set -e
+
+# Read input JSON from stdin
+read -r input_json
+
+agent_id=$(echo "$input_json" | jq -r '.agent_id // "unknown"')
+agent_type=$(echo "$input_json" | jq -r '.agent_type // "unknown"')
+cwd=$(echo "$input_json" | jq -r '.cwd // "unknown"')
+
+# Log to file
+LOG_FILE="$HOME/.claude/logs/subagents.log"
+mkdir -p "$(dirname "$LOG_FILE")"
+
+echo "[$(date '+%Y-%m-%d %H:%M:%S')] START | Agent: $agent_type | ID: $agent_id | CWD: $cwd" >> "$LOG_FILE"
+
+# Always allow
+exit 0

package/framework/hooks/subagent-stop-validate.cjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// subagent-stop-validate.cjs - Log subagent completion and optionally validate output
+// Hook: SubagentStop — v5.3
+
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+
+let inputJson = '{}';
+try {
+  inputJson = fs.readFileSync(0, 'utf8');
+} catch (e) {
+  inputJson = '{}';
+}
+
+let parsed = {};
+try {
+  parsed = JSON.parse(inputJson);
+} catch (e) {
+  parsed = {};
+}
+
+const agentId = parsed.agent_id || 'unknown';
+const agentType = parsed.agent_type || 'unknown';
+
+// Log to file
+const logFile = path.join(HOME, '.claude', 'logs', 'subagents.log');
+fs.mkdirSync(path.dirname(logFile), { recursive: true });
+
+const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+fs.appendFileSync(logFile, `[${timestamp}] STOP  | Agent: ${agentType} | ID: ${agentId}\n`);
+
+// For research agents, could add validation here
+// if (agentType === 'researcher') {
+//   // Check if required outputs exist
+// }
+
+// Always allow completion
+process.exit(0);