@yail259/overnight 0.2.0 → 0.3.0

package/dist/cli.js

@@ -8760,6 +8760,55 @@ var require_public_api = __commonJS((exports) => {
   exports.stringify = stringify;
 });
 
+// node_modules/yaml/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var composer = require_composer();
+  var Document = require_Document();
+  var Schema = require_Schema();
+  var errors = require_errors();
+  var Alias = require_Alias();
+  var identity = require_identity();
+  var Pair = require_Pair();
+  var Scalar = require_Scalar();
+  var YAMLMap = require_YAMLMap();
+  var YAMLSeq = require_YAMLSeq();
+  var cst = require_cst();
+  var lexer = require_lexer();
+  var lineCounter = require_line_counter();
+  var parser = require_parser();
+  var publicApi = require_public_api();
+  var visit = require_visit();
+  exports.Composer = composer.Composer;
+  exports.Document = Document.Document;
+  exports.Schema = Schema.Schema;
+  exports.YAMLError = errors.YAMLError;
+  exports.YAMLParseError = errors.YAMLParseError;
+  exports.YAMLWarning = errors.YAMLWarning;
+  exports.Alias = Alias.Alias;
+  exports.isAlias = identity.isAlias;
+  exports.isCollection = identity.isCollection;
+  exports.isDocument = identity.isDocument;
+  exports.isMap = identity.isMap;
+  exports.isNode = identity.isNode;
+  exports.isPair = identity.isPair;
+  exports.isScalar = identity.isScalar;
+  exports.isSeq = identity.isSeq;
+  exports.Pair = Pair.Pair;
+  exports.Scalar = Scalar.Scalar;
+  exports.YAMLMap = YAMLMap.YAMLMap;
+  exports.YAMLSeq = YAMLSeq.YAMLSeq;
+  exports.CST = cst;
+  exports.Lexer = lexer.Lexer;
+  exports.LineCounter = lineCounter.LineCounter;
+  exports.Parser = parser.Parser;
+  exports.parse = publicApi.parse;
+  exports.parseAllDocuments = publicApi.parseAllDocuments;
+  exports.parseDocument = publicApi.parseDocument;
+  exports.stringify = publicApi.stringify;
+  exports.visit = visit.visit;
+  exports.visitAsync = visit.visitAsync;
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -8777,53 +8826,8 @@ var {
 } = import__.default;
 
 // src/cli.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "fs";
-
-// node_modules/yaml/dist/index.js
-var composer = require_composer();
-var Document = require_Document();
-var Schema = require_Schema();
-var errors = require_errors();
-var Alias = require_Alias();
-var identity = require_identity();
-var Pair = require_Pair();
-var Scalar = require_Scalar();
-var YAMLMap = require_YAMLMap();
-var YAMLSeq = require_YAMLSeq();
-var cst = require_cst();
-var lexer = require_lexer();
-var lineCounter = require_line_counter();
-var parser = require_parser();
-var publicApi = require_public_api();
-var visit = require_visit();
-var $Composer = composer.Composer;
-var $Document = Document.Document;
-var $Schema = Schema.Schema;
-var $YAMLError = errors.YAMLError;
-var $YAMLParseError = errors.YAMLParseError;
-var $YAMLWarning = errors.YAMLWarning;
-var $Alias = Alias.Alias;
-var $isAlias = identity.isAlias;
-var $isCollection = identity.isCollection;
-var $isDocument = identity.isDocument;
-var $isMap = identity.isMap;
-var $isNode = identity.isNode;
-var $isPair = identity.isPair;
-var $isScalar = identity.isScalar;
-var $isSeq = identity.isSeq;
-var $Pair = Pair.Pair;
-var $Scalar = Scalar.Scalar;
-var $YAMLMap = YAMLMap.YAMLMap;
-var $YAMLSeq = YAMLSeq.YAMLSeq;
-var $Lexer = lexer.Lexer;
-var $LineCounter = lineCounter.LineCounter;
-var $Parser = parser.Parser;
-var $parse = publicApi.parse;
-var $parseAllDocuments = publicApi.parseAllDocuments;
-var $parseDocument = publicApi.parseDocument;
-var $stringify = publicApi.stringify;
-var $visit = visit.visit;
-var $visitAsync = visit.visitAsync;
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
 
 // src/types.ts
 var DEFAULT_TOOLS = ["Read", "Edit", "Write", "Glob", "Grep"];
@@ -8833,8 +8837,11 @@ var DEFAULT_RETRY_COUNT = 3;
 var DEFAULT_RETRY_DELAY = 5;
 var DEFAULT_VERIFY_PROMPT = "Review what you just implemented. Check for correctness, completeness, and compile errors. Fix any issues you find.";
 var DEFAULT_STATE_FILE = ".overnight-state.json";
+var DEFAULT_GOAL_STATE_FILE = ".overnight-goal-state.json";
 var DEFAULT_NTFY_TOPIC = "overnight";
 var DEFAULT_MAX_TURNS = 100;
+var DEFAULT_MAX_ITERATIONS = 20;
+var DEFAULT_CONVERGENCE_THRESHOLD = 3;
 var DEFAULT_DENY_PATTERNS = [
   "**/.env",
   "**/.env.*",
@@ -8905,7 +8912,7 @@ function createSecurityHooks(config) {
     if (sandboxDir && !isPathWithinSandbox(filePath, sandboxDir)) {
       return {
         hookSpecificOutput: {
-          hookEventName,
+          hookEventName: "PreToolUse",
           permissionDecision: "deny",
           permissionDecisionReason: `Path "${filePath}" is outside sandbox directory "${sandboxDir}"`
         }
@@ -8915,7 +8922,7 @@ function createSecurityHooks(config) {
     if (matchedPattern) {
       return {
         hookSpecificOutput: {
-          hookEventName,
+          hookEventName: "PreToolUse",
           permissionDecision: "deny",
           permissionDecisionReason: `Path "${filePath}" matches deny pattern "${matchedPattern}"`
         }
@@ -15277,7 +15284,7 @@ var require_limit = __commonJS2((exports) => {
   };
   exports.default = formatLimitPlugin;
 });
-var require_dist = __commonJS2((exports, module) => {
+var require_dist2 = __commonJS2((exports, module) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var formats_1 = require_formats();
   var limit_1 = require_limit();
@@ -25429,7 +25436,7 @@ var ServerResultSchema = union([
 var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
 var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
 var import_ajv = __toESM2(require_ajv(), 1);
-var import_ajv_formats = __toESM2(require_dist(), 1);
+var import_ajv_formats = __toESM2(require_dist2(), 1);
 var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
 var McpZodTypeKind;
 (function(McpZodTypeKind2) {
@@ -25711,7 +25718,7 @@ function getToolDetail(toolName, toolInput) {
   return "";
 }
 async function collectResultWithProgress(prompt, options, progress, onSessionId) {
-  let sessionId2;
+  let sessionId;
   let result;
   let lastError;
   try {
@@ -25722,8 +25729,10 @@ async function collectResultWithProgress(prompt, options, progress, onSessionId)
 [DEBUG] message.type=${message.type}, keys=${Object.keys(message).join(",")}`);
       }
       if (message.type === "result") {
-        result = message.result;
-        sessionId2 = message.session_id;
+        sessionId = message.session_id;
+        if (message.subtype === "success") {
+          result = message.result;
+        }
       } else if (message.type === "assistant" && "message" in message) {
         const assistantMsg = message.message;
         if (assistantMsg.content) {
@@ -25739,9 +25748,9 @@ async function collectResultWithProgress(prompt, options, progress, onSessionId)
         }
       } else if (message.type === "system" && "subtype" in message) {
         if (message.subtype === "init") {
-          sessionId2 = message.session_id;
-          if (sessionId2 && onSessionId) {
-            onSessionId(sessionId2);
+          sessionId = message.session_id;
+          if (sessionId && onSessionId) {
+            onSessionId(sessionId);
           }
         }
       }
@@ -25750,7 +25759,7 @@ async function collectResultWithProgress(prompt, options, progress, onSessionId)
     lastError = e.message;
     throw e;
   }
-  return { sessionId: sessionId2, result, error: lastError };
+  return { sessionId, result, error: lastError };
 }
 async function runJob(config2, log, options) {
   const startTime = Date.now();
@@ -25787,6 +25796,7 @@ async function runJob(config2, log, options) {
   } else {
     logMsg(`\x1B[36m▶\x1B[0m ${taskPreview}`);
   }
+  let sessionId;
   for (let attempt = 0;attempt <= retryCount; attempt++) {
     try {
       const securityHooks = config2.security ? createSecurityHooks(config2.security) : undefined;
@@ -25799,16 +25809,15 @@ async function runJob(config2, log, options) {
         ...securityHooks && { hooks: securityHooks },
         ...resumeSessionId && { resume: resumeSessionId }
       };
-      let sessionId2;
       let result;
       const prompt = resumeSessionId ? "Continue where you left off. Complete the original task." : config2.prompt;
       progress.start(resumeSessionId ? "Resuming" : "Working");
       try {
         const collected = await runWithTimeout(collectResultWithProgress(prompt, sdkOptions, progress, (id) => {
-          sessionId2 = id;
+          sessionId = id;
           options?.onSessionId?.(id);
         }), timeout);
-        sessionId2 = collected.sessionId;
+        sessionId = collected.sessionId;
         result = collected.result;
         progress.stop();
       } catch (e) {
@@ -25816,8 +25825,8 @@ async function runJob(config2, log, options) {
         if (e.message === "TIMEOUT") {
           if (attempt < retryCount) {
             retriesUsed = attempt + 1;
-            if (sessionId2) {
-              resumeSessionId = sessionId2;
+            if (sessionId) {
+              resumeSessionId = sessionId;
             }
             const delay = retryDelay * Math.pow(2, attempt);
             logMsg(`\x1B[33m⚠ Timeout after ${config2.timeout_seconds ?? DEFAULT_TIMEOUT}s, retrying in ${delay}s (${attempt + 1}/${retryCount})\x1B[0m`);
@@ -25836,11 +25845,11 @@ async function runJob(config2, log, options) {
         }
         throw e;
       }
-      if (config2.verify !== false && sessionId2) {
+      if (config2.verify !== false && sessionId) {
         progress.start("Verifying");
         const verifyOptions = {
           allowedTools: tools,
-          resume: sessionId2,
+          resume: sessionId,
           permissionMode: "acceptEdits",
           ...claudePath && { pathToClaudeCodeExecutable: claudePath },
           ...config2.working_dir && { cwd: config2.working_dir },
@@ -25849,7 +25858,7 @@ async function runJob(config2, log, options) {
         const fixPrompt = verifyPrompt + " If you find any issues, fix them now. Only report issues you cannot fix.";
         try {
           const verifyResult = await runWithTimeout(collectResultWithProgress(fixPrompt, verifyOptions, progress, (id) => {
-            sessionId2 = id;
+            sessionId = id;
             options?.onSessionId?.(id);
           }), timeout / 2);
           progress.stop();
@@ -25928,7 +25937,7 @@ function taskKey(config2) {
   return createHash("sha256").update(config2.prompt).digest("hex").slice(0, 12);
 }
 function validateDag(configs) {
-  const ids = new Set(configs.map((c) => c.id).filter(Boolean));
+  const ids = new Set(configs.map((c) => c.id).filter((id) => Boolean(id)));
   for (const c of configs) {
     for (const dep of c.depends_on ?? []) {
       if (!ids.has(dep)) {
@@ -26198,55 +26207,860 @@ function generateReport(results, totalDuration, outputPath) {
   return content;
 }
 
+// src/goal-runner.ts
+var import_yaml = __toESM(require_dist(), 1);
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { execSync as execSync2 } from "child_process";
+var ITERATION_DIR = ".overnight-iterations";
+function ensureIterationDir() {
+  if (!existsSync5(ITERATION_DIR)) {
+    mkdirSync3(ITERATION_DIR, { recursive: true });
+  }
+}
+function saveGoalState(state, stateFile) {
+  writeFileSync3(stateFile, JSON.stringify(state, null, 2));
+}
+function loadGoalState(stateFile) {
+  if (!existsSync5(stateFile))
+    return null;
+  return JSON.parse(readFileSync3(stateFile, "utf-8"));
+}
+function saveIterationState(iteration, state) {
+  ensureIterationDir();
+  writeFileSync3(`${ITERATION_DIR}/iteration-${iteration}-state.yaml`, import_yaml.stringify(state));
+}
+function saveIterationNarrative(iteration, narrative) {
+  ensureIterationDir();
+  writeFileSync3(`${ITERATION_DIR}/iteration-${iteration}-summary.md`, narrative);
+}
+function loadPreviousIterationState(iteration) {
+  const path = `${ITERATION_DIR}/iteration-${iteration}-state.yaml`;
+  if (!existsSync5(path))
+    return null;
+  return import_yaml.parse(readFileSync3(path, "utf-8"));
+}
+function loadPreviousNarrative(iteration) {
+  const path = `${ITERATION_DIR}/iteration-${iteration}-summary.md`;
+  if (!existsSync5(path))
+    return null;
+  return readFileSync3(path, "utf-8");
+}
+function isConverging(states, threshold) {
+  if (states.length < threshold)
+    return true;
+  const recent = states.slice(-threshold);
+  const remainingCounts = recent.map((s) => s.remaining_items.length);
+  for (let i = 1;i < remainingCounts.length; i++) {
+    if (remainingCounts[i] < remainingCounts[i - 1]) {
+      return true;
+    }
+  }
+  return false;
+}
+var SPINNER_FRAMES2 = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+class ProgressDisplay2 {
+  interval = null;
+  frame = 0;
+  startTime = Date.now();
+  currentActivity = "Working";
+  start(activity) {
+    this.currentActivity = activity;
+    this.startTime = Date.now();
+    this.frame = 0;
+    if (this.interval)
+      return;
+    this.interval = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - this.startTime) / 1000);
+      process.stdout.write(`\r\x1B[K${SPINNER_FRAMES2[this.frame]} ${this.currentActivity} (${elapsed}s)`);
+      this.frame = (this.frame + 1) % SPINNER_FRAMES2.length;
+    }, 100);
+  }
+  stop(finalMessage) {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    process.stdout.write("\r\x1B[K");
+    if (finalMessage)
+      console.log(finalMessage);
+  }
+}
+var claudeExecutablePath2;
+function findClaudeExecutable2() {
+  if (claudeExecutablePath2 !== undefined)
+    return claudeExecutablePath2;
+  if (process.env.CLAUDE_CODE_PATH) {
+    claudeExecutablePath2 = process.env.CLAUDE_CODE_PATH;
+    return claudeExecutablePath2;
+  }
+  try {
+    const cmd = process.platform === "win32" ? "where claude" : "which claude";
+    claudeExecutablePath2 = execSync2(cmd, { encoding: "utf-8" }).trim().split(`
+`)[0];
+    return claudeExecutablePath2;
+  } catch {
+    const commonPaths = [
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+      `${process.env.HOME}/.local/bin/claude`
+    ];
+    for (const p of commonPaths) {
+      if (existsSync5(p)) {
+        claudeExecutablePath2 = p;
+        return claudeExecutablePath2;
+      }
+    }
+  }
+  return;
+}
+async function runClaudePrompt(prompt, config2, log, progress, resumeSessionId) {
+  const claudePath = findClaudeExecutable2();
+  if (!claudePath) {
+    throw new Error("Claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash");
+  }
+  const tools = config2.defaults?.allowed_tools ?? DEFAULT_TOOLS;
+  const timeout = (config2.defaults?.timeout_seconds ?? DEFAULT_TIMEOUT) * 1000;
+  const security = config2.defaults?.security;
+  const securityHooks = security ? createSecurityHooks(security) : undefined;
+  const sdkOptions = {
+    allowedTools: tools,
+    permissionMode: "acceptEdits",
+    pathToClaudeCodeExecutable: claudePath,
+    ...security?.max_turns && { maxTurns: security.max_turns },
+    ...securityHooks && { hooks: securityHooks },
+    ...resumeSessionId && { resume: resumeSessionId }
+  };
+  let sessionId;
+  let result;
+  const conversation = query({ prompt, options: sdkOptions });
+  for await (const message of conversation) {
+    if (message.type === "result") {
+      sessionId = message.session_id;
+      if (message.subtype === "success") {
+        result = message.result;
+      }
+    } else if (message.type === "system" && "subtype" in message) {
+      if (message.subtype === "init") {
+        sessionId = message.session_id;
+      }
+    }
+  }
+  return { result, sessionId };
+}
+function buildIterationPrompt(goal, iteration, previousState, previousNarrative) {
+  const parts = [];
+  parts.push(`# Goal
+
+${goal.goal}`);
+  if (goal.acceptance_criteria && goal.acceptance_criteria.length > 0) {
+    parts.push(`
+# Acceptance Criteria
+
+${goal.acceptance_criteria.map((c) => `- ${c}`).join(`
+`)}`);
+  }
+  if (goal.constraints && goal.constraints.length > 0) {
+    parts.push(`
+# Constraints
+
+${goal.constraints.map((c) => `- ${c}`).join(`
+`)}`);
+  }
+  if (goal.verification_commands && goal.verification_commands.length > 0) {
+    parts.push(`
+# Verification Commands (must pass)
+
+${goal.verification_commands.map((c) => `- \`${c}\``).join(`
+`)}`);
+  }
+  parts.push(`
+# Iteration ${iteration}`);
+  if (previousState && previousNarrative) {
+    parts.push(`
+## Previous Iteration State
+
+### Completed Items
+${previousState.completed_items.map((i) => `- ${i}`).join(`
+`) || "- (none yet)"}`);
+    parts.push(`
+### Remaining Items
+${previousState.remaining_items.map((i) => `- ${i}`).join(`
+`) || "- (none)"}`);
+    parts.push(`
+### Known Issues
+${previousState.known_issues.map((i) => `- ${i}`).join(`
+`) || "- (none)"}`);
+    parts.push(`
+### Files Modified
+${previousState.files_modified.map((f) => `- ${f}`).join(`
+`) || "- (none)"}`);
+    parts.push(`
+### Previous Summary
+
+${previousNarrative}`);
+  }
+  parts.push(`
+# Instructions
+
+You are iteration ${iteration} of an autonomous build loop working toward the goal above.
+
+1. Assess the current state of the project
+2. Identify the highest-priority remaining work
+3. Implement as much as you can in this iteration
+4. When done, output your structured state update in the following EXACT format:
+
+\`\`\`yaml
+completed_items:
+  - "item 1 you completed"
+  - "item 2 you completed"
+remaining_items:
+  - "item still to do"
+  - "another item still to do"
+known_issues:
+  - "any issues found"
+files_modified:
+  - "path/to/file1.ts"
+  - "path/to/file2.ts"
+agent_done: false  # Set to true ONLY if you believe the goal is fully met
+\`\`\`
+
+5. After the YAML block, write a brief narrative summary (2-3 paragraphs) of what you did, what challenges you encountered, and what the next iteration should focus on.
+
+IMPORTANT: Always output the YAML block wrapped in \`\`\`yaml ... \`\`\` fences. This is how state is tracked between iterations.`);
+  return parts.join(`
+`);
+}
+function parseIterationOutput(output, iteration) {
+  const yamlMatch = output.match(/```yaml\n([\s\S]*?)\n```/);
+  let state;
+  if (yamlMatch) {
+    try {
+      const parsed = import_yaml.parse(yamlMatch[1]);
+      state = {
+        iteration,
+        completed_items: parsed.completed_items ?? [],
+        remaining_items: parsed.remaining_items ?? [],
+        known_issues: parsed.known_issues ?? [],
+        files_modified: parsed.files_modified ?? [],
+        agent_done: parsed.agent_done ?? false,
+        timestamp: new Date().toISOString()
+      };
+    } catch {
+      state = {
+        iteration,
+        completed_items: [],
+        remaining_items: ["(failed to parse agent output)"],
+        known_issues: ["Agent output did not contain valid YAML state block"],
+        files_modified: [],
+        agent_done: false,
+        timestamp: new Date().toISOString()
+      };
+    }
+  } else {
+    state = {
+      iteration,
+      completed_items: [],
+      remaining_items: ["(no structured output from agent)"],
+      known_issues: ["Agent did not output a YAML state block"],
+      files_modified: [],
+      agent_done: false,
+      timestamp: new Date().toISOString()
+    };
+  }
+  let narrative;
+  if (yamlMatch) {
+    const afterYaml = output.slice(output.indexOf("```", output.indexOf("```yaml") + 7) + 3).trim();
+    narrative = afterYaml || "(no narrative provided)";
+  } else {
+    narrative = output;
+  }
+  return { state, narrative };
+}
+function buildGatePrompt(goal, iterationStates) {
+  const lastState = iterationStates[iterationStates.length - 1];
+  const parts = [];
+  parts.push(`# Final Verification Gate
+
+You are a dedicated verification agent. You did NOT write this code. Your only job is to determine if the goal has been met to production quality. Be rigorous and honest.
+
+## Goal
+
+${goal.goal}`);
+  if (goal.acceptance_criteria && goal.acceptance_criteria.length > 0) {
+    parts.push(`
+## Acceptance Criteria (ALL must be met)
+
+${goal.acceptance_criteria.map((c, i) => `${i + 1}. ${c}`).join(`
+`)}`);
+  }
+  if (goal.verification_commands && goal.verification_commands.length > 0) {
+    parts.push(`
+## Required Verification Commands
+
+Run ALL of these. Each must pass:
+${goal.verification_commands.map((c) => `- \`${c}\``).join(`
+`)}`);
+  }
+  parts.push(`
+## Build Agent's Final State
+
+### Completed Items
+${lastState?.completed_items.map((i) => `- ${i}`).join(`
+`) || "- (none)"}
+
+### Claimed Remaining Items
+${lastState?.remaining_items.map((i) => `- ${i}`).join(`
+`) || "- (none)"}
+
+### Known Issues
+${lastState?.known_issues.map((i) => `- ${i}`).join(`
+`) || "- (none)"}
+
+## Instructions
+
+Perform EVERY form of verification you can:
+
+1. **Build check**: Does the project compile/build without errors?
+2. **Lint/type check**: Are there type errors or lint warnings?
+3. **Unit tests**: Do all unit tests pass?
+4. **E2E tests**: Do end-to-end tests pass?
+5. **Visual review**: Check rendered output if applicable
+6. **Manual walkthrough**: Trace key user flows through the code
+7. **Acceptance criteria**: Verify each criterion explicitly
+8. **Verification commands**: Run each command listed above
+9. **Code quality**: Look for obvious bugs, missing error handling, broken imports
+10. **Integration**: Is everything wired up? No dead code, no missing connections?
+
+After your review, output your verdict in this EXACT format:
+
+\`\`\`yaml
+passed: false  # or true
+checks:
+  - name: "Build"
+    passed: true
+    output: "npm run build succeeded"
+  - name: "Unit tests"
+    passed: false
+    output: "3 tests failed: ..."
+summary: "Brief overall assessment"
+failures:
+  - "Description of failure 1"
+  - "Description of failure 2"
+\`\`\`
+
+Be thorough. Do not let bad quality pass. If ANYTHING is broken, set passed: false.`);
+  return parts.join(`
+`);
+}
+function parseGateOutput(output) {
+  const yamlMatch = output.match(/```yaml\n([\s\S]*?)\n```/);
+  if (yamlMatch) {
+    try {
+      const parsed = import_yaml.parse(yamlMatch[1]);
+      return {
+        passed: parsed.passed ?? false,
+        checks: (parsed.checks ?? []).map((c) => ({
+          name: c.name ?? "unknown",
+          passed: c.passed ?? false,
+          output: c.output ?? ""
+        })),
+        summary: parsed.summary ?? "",
+        failures: parsed.failures ?? []
+      };
+    } catch {
+      return {
+        passed: false,
+        checks: [],
+        summary: "Failed to parse gate agent output",
+        failures: ["Gate agent output was not valid YAML"]
+      };
+    }
+  }
+  return {
+    passed: false,
+    checks: [],
+    summary: "Gate agent did not output a structured verdict",
+    failures: ["No YAML verdict block found in gate agent output"]
+  };
+}
+async function runGoal(goal, options = {}) {
+  const stateFile = options.stateFile ?? DEFAULT_GOAL_STATE_FILE;
+  const log = options.log ?? (() => {});
+  const maxIterations = goal.max_iterations ?? DEFAULT_MAX_ITERATIONS;
+  const convergenceThreshold = goal.convergence_threshold ?? DEFAULT_CONVERGENCE_THRESHOLD;
+  const progress = new ProgressDisplay2;
+  let runState = loadGoalState(stateFile) ?? {
+    goal: goal.goal,
+    iterations: [],
+    gate_results: [],
+    status: "running",
+    timestamp: new Date().toISOString()
+  };
+  const startIteration = runState.iterations.length + 1;
+  if (startIteration > 1) {
+    log(`\x1B[1movernight: Resuming from iteration ${startIteration}\x1B[0m`);
+  } else {
+    log(`\x1B[1movernight: Starting goal loop\x1B[0m`);
+    log(`\x1B[2mGoal: ${goal.goal.slice(0, 80)}${goal.goal.length > 80 ? "..." : ""}\x1B[0m`);
+    log(`\x1B[2mMax iterations: ${maxIterations}, convergence threshold: ${convergenceThreshold}\x1B[0m`);
+  }
+  log("");
+  for (let iteration = startIteration;iteration <= maxIterations; iteration++) {
+    log(`\x1B[1m━━━ Iteration ${iteration}/${maxIterations} ━━━\x1B[0m`);
+    const prevState = iteration > 1 ? loadPreviousIterationState(iteration - 1) : null;
+    const prevNarrative = iteration > 1 ? loadPreviousNarrative(iteration - 1) : null;
+    if (!isConverging(runState.iterations, convergenceThreshold)) {
+      log(`\x1B[33m⚠ Build loop stalled — remaining items unchanged for ${convergenceThreshold} iterations\x1B[0m`);
+      runState.status = "stalled";
+      saveGoalState(runState, stateFile);
+      break;
+    }
+    const prompt = buildIterationPrompt(goal, iteration, prevState, prevNarrative);
+    progress.start(`Iteration ${iteration}`);
+    try {
+      const { result } = await runClaudePrompt(prompt, goal, log, progress);
+      progress.stop();
+      if (!result) {
+        log(`\x1B[31m✗ No output from build agent\x1B[0m`);
+        continue;
+      }
+      const { state: iterState, narrative } = parseIterationOutput(result, iteration);
+      saveIterationState(iteration, iterState);
+      saveIterationNarrative(iteration, narrative);
+      runState.iterations.push(iterState);
+      runState.timestamp = new Date().toISOString();
+      saveGoalState(runState, stateFile);
+      log(`\x1B[32m✓ Iteration ${iteration} complete\x1B[0m`);
+      log(`  Completed: ${iterState.completed_items.length} items`);
+      log(`  Remaining: ${iterState.remaining_items.length} items`);
+      if (iterState.known_issues.length > 0) {
+        log(`  Issues: ${iterState.known_issues.length}`);
+      }
+      if (iterState.agent_done) {
+        log(`
+\x1B[36m◆ Build agent reports goal is met — running final gate...\x1B[0m
+`);
+        break;
+      }
+    } catch (e) {
+      progress.stop();
+      const error2 = e;
+      log(`\x1B[31m✗ Iteration ${iteration} failed: ${error2.message}\x1B[0m`);
+      if (error2.message === "TIMEOUT") {
+        log(`\x1B[33m  Continuing to next iteration...\x1B[0m`);
+        continue;
+      }
+      continue;
+    }
+    log("");
+  }
+  if (runState.status === "running") {
+    const maxGateAttempts = 3;
+    for (let gateAttempt = 1;gateAttempt <= maxGateAttempts; gateAttempt++) {
+      log(`\x1B[1m━━━ Final Gate (attempt ${gateAttempt}/${maxGateAttempts}) ━━━\x1B[0m`);
+      const gatePrompt = buildGatePrompt(goal, runState.iterations);
+      const gateGoalConfig = {
+        ...goal,
+        defaults: {
+          ...goal.defaults,
+          allowed_tools: [...goal.defaults?.allowed_tools ?? DEFAULT_TOOLS, "Bash"]
+        }
+      };
+      progress.start("Running final gate");
+      try {
+        const { result } = await runClaudePrompt(gatePrompt, gateGoalConfig, log, progress);
+        progress.stop();
+        if (!result) {
+          log(`\x1B[31m✗ No output from gate agent\x1B[0m`);
+          continue;
+        }
+        const gateResult = parseGateOutput(result);
+        runState.gate_results.push(gateResult);
+        saveGoalState(runState, stateFile);
+        if (gateResult.passed) {
+          log(`\x1B[32m✓ GATE PASSED\x1B[0m`);
+          log(`  ${gateResult.summary}`);
+          for (const check2 of gateResult.checks) {
+            const icon = check2.passed ? "\x1B[32m✓\x1B[0m" : "\x1B[31m✗\x1B[0m";
+            log(`  ${icon} ${check2.name}`);
+          }
+          runState.status = "gate_passed";
+          saveGoalState(runState, stateFile);
+          break;
+        } else {
+          log(`\x1B[31m✗ GATE FAILED\x1B[0m`);
+          log(`  ${gateResult.summary}`);
+          for (const failure of gateResult.failures) {
+            log(`  \x1B[31m- ${failure}\x1B[0m`);
+          }
+          if (gateAttempt < maxGateAttempts) {
+            log(`
+\x1B[36m◆ Looping back to build agent with gate failures...\x1B[0m
+`);
+            const fixIteration = runState.iterations.length + 1;
+            const fixPrompt = buildGateFixPrompt(goal, gateResult, fixIteration);
+            progress.start(`Fix iteration ${fixIteration}`);
+            try {
+              const { result: fixResult } = await runClaudePrompt(fixPrompt, goal, log, progress);
+              progress.stop();
+              if (fixResult) {
+                const { state: fixState, narrative: fixNarrative } = parseIterationOutput(fixResult, fixIteration);
+                saveIterationState(fixIteration, fixState);
+                saveIterationNarrative(fixIteration, fixNarrative);
+                runState.iterations.push(fixState);
+                saveGoalState(runState, stateFile);
+                log(`\x1B[32m✓ Fix iteration complete\x1B[0m`);
+                log(`  Fixed: ${fixState.completed_items.length} items`);
+              }
+            } catch (e) {
+              progress.stop();
+              log(`\x1B[31m✗ Fix iteration failed: ${e.message}\x1B[0m`);
+            }
+          } else {
+            runState.status = "gate_failed";
+            saveGoalState(runState, stateFile);
+          }
+        }
+      } catch (e) {
+        progress.stop();
+        log(`\x1B[31m✗ Gate failed: ${e.message}\x1B[0m`);
+      }
+      log("");
+    }
+  }
+  if (runState.status === "running") {
+    const lastState = runState.iterations[runState.iterations.length - 1];
+    if (!lastState?.agent_done) {
+      log(`\x1B[33m⚠ Reached max iterations (${maxIterations}) without completion\x1B[0m`);
+      runState.status = "max_iterations";
+      saveGoalState(runState, stateFile);
+    }
+  }
+  return runState;
+}
+function buildGateFixPrompt(goal, gateResult, iteration) {
+  return `# Goal
+
+${goal.goal}
+
+# Urgent: Fix Gate Failures
+
+The final verification gate FAILED. You must fix these issues:
+
+## Failures
+
+${gateResult.failures.map((f) => `- ${f}`).join(`
+`)}
+
+## Check Results
+
+${gateResult.checks.map((c) => `- ${c.passed ? "PASS" : "FAIL"}: ${c.name} — ${c.output}`).join(`
+`)}
+
+## Gate Summary
+
+${gateResult.summary}
+
+# Instructions
+
+Fix ALL of the failures listed above. Focus exclusively on making the gate pass. Do not add new features.
+
+When done, output your state update:
+
+\`\`\`yaml
+completed_items:
+  - "fixed: description of what you fixed"
+remaining_items:
+  - "any remaining issues"
+known_issues:
+  - "any issues you could not fix"
+files_modified:
+  - "path/to/file.ts"
+agent_done: true
+\`\`\`
+
+Then write a brief summary of what you fixed.`;
+}
+function parseGoalFile(path) {
+  const content = readFileSync3(path, "utf-8");
+  let data;
+  try {
+    data = import_yaml.parse(content);
+  } catch (e) {
+    const error2 = e;
+    console.error(`\x1B[31mError parsing ${path}:\x1B[0m`);
+    console.error(`  ${error2.message.split(`
+`)[0]}`);
+    process.exit(1);
+  }
+  if (!data.goal) {
+    console.error(`\x1B[31mError: goal.yaml must have a 'goal' field\x1B[0m`);
+    process.exit(1);
+  }
+  return data;
+}
+
+// src/planner.ts
+import { writeFileSync as writeFileSync4, existsSync as existsSync6 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import * as readline from "readline";
+var claudeExecutablePath3;
+function findClaudeExecutable3() {
+  if (claudeExecutablePath3 !== undefined)
+    return claudeExecutablePath3;
+  if (process.env.CLAUDE_CODE_PATH) {
+    claudeExecutablePath3 = process.env.CLAUDE_CODE_PATH;
+    return claudeExecutablePath3;
+  }
+  try {
+    const cmd = process.platform === "win32" ? "where claude" : "which claude";
+    claudeExecutablePath3 = execSync3(cmd, { encoding: "utf-8" }).trim().split(`
+`)[0];
+    return claudeExecutablePath3;
+  } catch {
+    const commonPaths = [
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+      `${process.env.HOME}/.local/bin/claude`
+    ];
+    for (const p of commonPaths) {
+      if (existsSync6(p)) {
+        claudeExecutablePath3 = p;
+        return claudeExecutablePath3;
+      }
+    }
+  }
+  return;
+}
+function createReadline() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+function ask(rl, question) {
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => resolve2(answer.trim()));
+  });
+}
+var PLANNER_SYSTEM_PROMPT = `You are an expert software architect helping plan an autonomous overnight build.
+
+Your job is to have a focused design conversation with the user, then produce a goal.yaml file that an autonomous build agent will use to implement the project overnight.
+
+Guidelines:
+- Ask clarifying questions about scope, technology choices, priorities, and constraints
+- Keep the conversation focused and efficient — 3-5 rounds max
+- When you have enough information, produce the goal.yaml
+- The goal.yaml should be specific enough for an agent to work autonomously
+- Include concrete acceptance criteria that can be verified
+- Include verification commands when possible (build, test, lint)
+- Set realistic constraints
+
+When you're ready to produce the final plan, output it in this format:
+
+\`\`\`yaml
+goal: "Clear description of what to build"
+
+acceptance_criteria:
+  - "Specific, verifiable criterion 1"
+  - "Specific, verifiable criterion 2"
+
+verification_commands:
+  - "npm run build"
+  - "npm test"
+
+constraints:
+  - "Don't modify existing API contracts"
+
+max_iterations: 15
+convergence_threshold: 3
+
+defaults:
+  timeout_seconds: 600
+  allowed_tools:
+    - Read
+    - Edit
+    - Write
+    - Glob
+    - Grep
+    - Bash
+  security:
+    sandbox_dir: "."
+    max_turns: 150
+\`\`\`
+
+IMPORTANT: Only output the yaml block when you and the user agree the plan is ready. Before that, ask questions and discuss.`;
+async function runPlanner(initialGoal, options = {}) {
+  const log = options.log ?? ((msg) => console.log(msg));
+  const outputFile = options.outputFile ?? "goal.yaml";
+  const claudePath = findClaudeExecutable3();
+  if (!claudePath) {
+    log("\x1B[31m✗ Error: Could not find 'claude' CLI.\x1B[0m");
+    return null;
+  }
+  log("\x1B[1movernight plan: Interactive design session\x1B[0m");
+  log("\x1B[2mDescribe your goal and I'll help shape it into a plan.\x1B[0m");
+  log(`\x1B[2mType 'done' to finalize, 'quit' to abort.\x1B[0m
+`);
+  const rl = createReadline();
+  const conversationHistory = [];
+  let currentPrompt = `The user wants to plan the following project for an overnight autonomous build:
+
+${initialGoal}
+
+Ask clarifying questions to understand scope, tech choices, priorities, and constraints. Be concise.`;
+  try {
+    let sessionId;
+    for (let round = 0;round < 10; round++) {
+      const sdkOptions = {
+        allowedTools: ["Read", "Glob", "Grep"],
+        systemPrompt: PLANNER_SYSTEM_PROMPT,
+        permissionMode: "acceptEdits",
+        pathToClaudeCodeExecutable: claudePath,
+        ...sessionId && { resume: sessionId }
+      };
+      let result;
+      const conversation = query({ prompt: currentPrompt, options: sdkOptions });
+      for await (const message of conversation) {
+        if (message.type === "result") {
+          sessionId = message.session_id;
+          if (message.subtype === "success") {
+            result = message.result;
+          }
+        } else if (message.type === "system" && "subtype" in message) {
+          if (message.subtype === "init") {
+            sessionId = message.session_id;
+          }
+        }
+      }
+      if (!result) {
+        log("\x1B[31m✗ No response from planner\x1B[0m");
+        break;
+      }
+      conversationHistory.push({ role: "assistant", content: result });
+      const yamlMatch = result.match(/```yaml\n([\s\S]*?)\n```/);
+      if (yamlMatch) {
+        log(`
+\x1B[1m━━━ Proposed Plan ━━━\x1B[0m
+`);
+        log(yamlMatch[1]);
+        log(`
+\x1B[1m━━━━━━━━━━━━━━━━━━━━\x1B[0m
+`);
+        const answer = await ask(rl, "\x1B[36m?\x1B[0m Accept this plan? (yes/no/revise): ");
+        if (answer.toLowerCase() === "yes" || answer.toLowerCase() === "y") {
+          writeFileSync4(outputFile, yamlMatch[1]);
+          log(`
+\x1B[32m✓ Plan saved to ${outputFile}\x1B[0m`);
+          log(`Run with: \x1B[1movernight run ${outputFile}\x1B[0m`);
+          rl.close();
+          const { parse: parseYaml2 } = await Promise.resolve().then(() => __toESM(require_dist(), 1));
+          return parseYaml2(yamlMatch[1]);
+        } else if (answer.toLowerCase() === "quit" || answer.toLowerCase() === "q") {
+          log("\x1B[33mAborted\x1B[0m");
+          rl.close();
+          return null;
+        } else {
+          const revision = await ask(rl, "\x1B[36m?\x1B[0m What would you like to change? ");
+          currentPrompt = revision;
+          conversationHistory.push({ role: "user", content: revision });
+          continue;
+        }
+      }
+      log(`
+\x1B[2m─── Planner ───\x1B[0m
+`);
+      log(result);
+      log("");
+      const userInput = await ask(rl, "\x1B[36m>\x1B[0m ");
+      if (userInput.toLowerCase() === "done") {
+        currentPrompt = "The user is satisfied. Please produce the final goal.yaml now based on our discussion.";
+        conversationHistory.push({ role: "user", content: currentPrompt });
+        continue;
+      }
+      if (userInput.toLowerCase() === "quit" || userInput.toLowerCase() === "q") {
+        log("\x1B[33mAborted\x1B[0m");
+        rl.close();
+        return null;
+      }
+      currentPrompt = userInput;
+      conversationHistory.push({ role: "user", content: userInput });
+    }
+  } finally {
+    rl.close();
+  }
+  log("\x1B[33m⚠ Design session ended without producing a plan\x1B[0m");
+  return null;
+}
+
 // src/cli.ts
 var AGENT_HELP = `
-# overnight - Batch Job Runner for Claude Code
+# overnight - Autonomous Build Runner for Claude Code
 
-Queue tasks, run them unattended, get results. Designed for overnight/AFK use.
+Two modes: goal-driven autonomous loops, or task-list batch jobs.
 
 ## Quick Start
 
 \`\`\`bash
-# Create a tasks.yaml file
-overnight init
+# Hammer mode: just give it a goal and go
+overnight hammer "Build a multiplayer MMO"
 
-# Run all tasks
-overnight run tasks.yaml
+# Or: design session first, then autonomous build
+overnight plan "Build a multiplayer game"   # Interactive design → goal.yaml
+overnight run goal.yaml --notify            # Autonomous build loop
 
-# Run with notifications and report
-overnight run tasks.yaml --notify -r report.md
+# Task mode: explicit task list
+overnight run tasks.yaml --notify
 \`\`\`
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| \`overnight run <file>\` | Run jobs from YAML file |
+| \`overnight hammer "<goal>"\` | Autonomous build loop from a string |
+| \`overnight plan "<goal>"\` | Interactive design session → goal.yaml |
+| \`overnight run <file>\` | Run goal.yaml (loop) or tasks.yaml (batch) |
 | \`overnight resume <file>\` | Resume interrupted run from checkpoint |
 | \`overnight single "<prompt>"\` | Run a single task directly |
-| \`overnight init\` | Create example tasks.yaml |
+| \`overnight init\` | Create example goal.yaml or tasks.yaml |
+
+## Goal Mode (goal.yaml)
+
+Autonomous convergence loop: agent iterates toward a goal, then a separate
+gate agent verifies everything before declaring done.
+
+\`\`\`yaml
+goal: "Build a clone of Flappy Bird with leaderboard"
+
+acceptance_criteria:
+  - "Game renders and is playable in browser"
+  - "Leaderboard persists scores to localStorage"
 
-## tasks.yaml Format
+verification_commands:
+  - "npm run build"
+  - "npm test"
+
+constraints:
+  - "Use vanilla JS, no frameworks"
+
+max_iterations: 15
+\`\`\`
+
+## Task Mode (tasks.yaml)
+
+Explicit task list with optional dependency DAG.
 
 \`\`\`yaml
 defaults:
-  timeout_seconds: 300      # Per-task timeout (default: 300)
-  verify: true              # Run verification pass (default: true)
-  allowed_tools:            # Whitelist tools (default: Read,Edit,Write,Glob,Grep)
-    - Read
-    - Edit
-    - Glob
-    - Grep
+  timeout_seconds: 300
+  verify: true
+  allowed_tools: [Read, Edit, Write, Glob, Grep]
 
 tasks:
-  # Simple format
   - "Fix the bug in auth.py"
-
-  # Detailed format
   - prompt: "Add input validation"
     timeout_seconds: 600
-    verify: false
-    allowed_tools: [Read, Edit, Bash, Glob, Grep]
 \`\`\`
 
 ## Key Options
@@ -26256,52 +27070,55 @@ tasks:
 | \`-o, --output <file>\` | Save results JSON |
 | \`-r, --report <file>\` | Generate markdown report |
 | \`-s, --state-file <file>\` | Custom checkpoint file |
+| \`--max-iterations <n>\` | Max build loop iterations (goal mode) |
 | \`--notify\` | Send push notification via ntfy.sh |
-| \`--notify-topic <topic>\` | ntfy.sh topic (default: overnight) |
 | \`-q, --quiet\` | Minimal output |
 
-## Features
-
-1. **Crash Recovery**: Auto-checkpoints after each job. Use \`overnight resume\` to continue.
-2. **Retry Logic**: Auto-retries 3x on API/network errors with exponential backoff.
-3. **Notifications**: \`--notify\` sends summary to ntfy.sh (free, no signup).
-4. **Reports**: \`-r report.md\` generates markdown summary with next steps.
-5. **Security**: No Bash by default. Whitelist tools per-task.
-
 ## Example Workflows
 
 \`\`\`bash
-# Development: run overnight, check in morning
-nohup overnight run tasks.yaml --notify -r report.md -o results.json > overnight.log 2>&1 &
+# Simplest: just hammer a goal overnight
+nohup overnight hammer "Build a REST API with auth and tests" --notify > overnight.log 2>&1 &
 
-# CI/CD: run and fail if any task fails
-overnight run tasks.yaml -q
+# Design first, then run
+overnight plan "Build a REST API with auth"
+nohup overnight run goal.yaml --notify > overnight.log 2>&1 &
 
-# Single task with Bash access
-overnight single "Run tests and fix failures" -T Read -T Edit -T Bash -T Glob
+# Batch tasks overnight
+nohup overnight run tasks.yaml --notify -r report.md > overnight.log 2>&1 &
 
-# Resume after crash/interrupt
-overnight resume tasks.yaml
+# Resume after crash
+overnight resume goal.yaml
 \`\`\`
 
 ## Exit Codes
 
-- 0: All tasks succeeded
-- 1: One or more tasks failed
+- 0: All tasks succeeded / gate passed
+- 1: Failures occurred / gate failed
 
 ## Files Created
 
-- \`.overnight-state.json\` - Checkpoint file (deleted on success)
+- \`.overnight-goal-state.json\` - Goal mode checkpoint
+- \`.overnight-iterations/\` - Per-iteration state + summaries
+- \`.overnight-state.json\` - Task mode checkpoint
 - \`report.md\` - Summary report (if -r used)
-- \`results.json\` - Full results (if -o used)
 
 Run \`overnight <command> --help\` for command-specific options.
 `;
+function isGoalFile(path) {
+  try {
+    const content = readFileSync5(path, "utf-8");
+    const data = import_yaml2.parse(content);
+    return typeof data?.goal === "string";
+  } catch {
+    return false;
+  }
+}
 function parseTasksFile(path, cliSecurity) {
-  const content = readFileSync3(path, "utf-8");
+  const content = readFileSync5(path, "utf-8");
   let data;
   try {
-    data = $parse(content);
+    data = import_yaml2.parse(content);
   } catch (e) {
     const error2 = e;
     console.error(`\x1B[31mError parsing ${path}:\x1B[0m`);
@@ -26368,69 +27185,146 @@ ${bold}Job Results${reset}`);
 ${bold}Summary:${reset} ${succeeded}/${results.length} succeeded`);
 }
 var program2 = new Command;
-program2.name("overnight").description("Batch job runner for Claude Code").version("0.2.0").action(() => {
+program2.name("overnight").description("Batch job runner for Claude Code").version("0.3.0").action(() => {
   console.log(AGENT_HELP);
 });
-program2.command("run").description("Run jobs from a YAML tasks file").argument("<tasks-file>", "Path to tasks.yaml file").option("-o, --output <file>", "Output file for results JSON").option("-q, --quiet", "Minimal output").option("-s, --state-file <file>", "Custom state file path").option("--notify", "Send push notification via ntfy.sh").option("--notify-topic <topic>", "ntfy.sh topic", DEFAULT_NTFY_TOPIC).option("-r, --report <file>", "Generate markdown report").option("--sandbox <dir>", "Sandbox directory (restrict file access)").option("--max-turns <n>", "Max agent iterations per task", String(DEFAULT_MAX_TURNS)).option("--audit-log <file>", "Audit log file path").option("--no-security", "Disable default security (deny patterns)").action(async (tasksFile, opts) => {
-  if (!existsSync5(tasksFile)) {
-    console.error(`Error: File not found: ${tasksFile}`);
-    process.exit(1);
-  }
-  const cliSecurity = opts.security === false ? undefined : {
-    ...opts.sandbox && { sandbox_dir: opts.sandbox },
-    ...opts.maxTurns && { max_turns: parseInt(opts.maxTurns, 10) },
-    ...opts.auditLog && { audit_log: opts.auditLog }
-  };
-  const { configs, security } = parseTasksFile(tasksFile, cliSecurity);
-  if (configs.length === 0) {
-    console.error("No tasks found in file");
+program2.command("run").description("Run goal.yaml (autonomous loop) or tasks.yaml (batch jobs)").argument("<file>", "Path to goal.yaml or tasks.yaml").option("-o, --output <file>", "Output file for results JSON").option("-q, --quiet", "Minimal output").option("-s, --state-file <file>", "Custom state file path").option("--notify", "Send push notification via ntfy.sh").option("--notify-topic <topic>", "ntfy.sh topic", DEFAULT_NTFY_TOPIC).option("-r, --report <file>", "Generate markdown report").option("--sandbox <dir>", "Sandbox directory (restrict file access)").option("--max-turns <n>", "Max agent iterations per task", String(DEFAULT_MAX_TURNS)).option("--max-iterations <n>", "Max build loop iterations (goal mode)", String(DEFAULT_MAX_ITERATIONS)).option("--audit-log <file>", "Audit log file path").option("--no-security", "Disable default security (deny patterns)").action(async (inputFile, opts) => {
+  if (!existsSync7(inputFile)) {
+    console.error(`Error: File not found: ${inputFile}`);
     process.exit(1);
   }
-  const existingState = loadState(opts.stateFile ?? DEFAULT_STATE_FILE);
-  if (existingState) {
-    const done = Object.keys(existingState.completed).length;
-    const pending = configs.filter((c) => !(taskKey(c) in existingState.completed)).length;
-    console.log(`\x1B[1movernight: Resuming — ${done} done, ${pending} remaining\x1B[0m`);
-    console.log(`\x1B[2mLast checkpoint: ${existingState.timestamp}\x1B[0m`);
+  if (isGoalFile(inputFile)) {
+    const goal = parseGoalFile(inputFile);
+    if (opts.maxIterations) {
+      goal.max_iterations = parseInt(opts.maxIterations, 10);
+    }
+    if (opts.sandbox) {
+      goal.defaults = goal.defaults ?? {};
+      goal.defaults.security = goal.defaults.security ?? {};
+      goal.defaults.security.sandbox_dir = opts.sandbox;
+    }
+    if (opts.maxTurns) {
+      goal.defaults = goal.defaults ?? {};
+      goal.defaults.security = goal.defaults.security ?? {};
+      goal.defaults.security.max_turns = parseInt(opts.maxTurns, 10);
+    }
+    const log = opts.quiet ? undefined : (msg) => console.log(msg);
+    const startTime = Date.now();
+    const runState = await runGoal(goal, {
+      stateFile: opts.stateFile ?? DEFAULT_GOAL_STATE_FILE,
+      log
+    });
+    const totalDuration = (Date.now() - startTime) / 1000;
+    if (opts.notify) {
+      const passed = runState.status === "gate_passed";
+      const title = passed ? `overnight: Goal completed (${runState.iterations.length} iterations)` : `overnight: ${runState.status} after ${runState.iterations.length} iterations`;
+      const message = passed ? `Gate passed. ${runState.iterations.length} iterations.` : `Status: ${runState.status}. Check report for details.`;
+      try {
+        await fetch(`https://ntfy.sh/${opts.notifyTopic ?? DEFAULT_NTFY_TOPIC}`, {
+          method: "POST",
+          headers: {
+            Title: title,
+            Priority: passed ? "default" : "high",
+            Tags: passed ? "white_check_mark" : "warning"
+          },
+          body: message
+        });
+        if (!opts.quiet)
+          console.log(`\x1B[2mNotification sent\x1B[0m`);
+      } catch {
+        if (!opts.quiet)
+          console.log("\x1B[33mWarning: Failed to send notification\x1B[0m");
+      }
+    }
+    if (!opts.quiet) {
+      console.log(`
+\x1B[1m━━━ Goal Run Summary ━━━\x1B[0m`);
+      console.log(`Status: ${runState.status === "gate_passed" ? "\x1B[32m" : "\x1B[31m"}${runState.status}\x1B[0m`);
+      console.log(`Iterations: ${runState.iterations.length}`);
+      console.log(`Gate attempts: ${runState.gate_results.length}`);
+      let durationStr;
+      if (totalDuration >= 3600) {
+        const hours = Math.floor(totalDuration / 3600);
+        const mins = Math.floor(totalDuration % 3600 / 60);
+        durationStr = `${hours}h ${mins}m`;
+      } else if (totalDuration >= 60) {
+        const mins = Math.floor(totalDuration / 60);
+        const secs = Math.floor(totalDuration % 60);
+        durationStr = `${mins}m ${secs}s`;
+      } else {
+        durationStr = `${totalDuration.toFixed(1)}s`;
+      }
+      console.log(`Duration: ${durationStr}`);
+      if (runState.gate_results.length > 0) {
+        const lastGate = runState.gate_results[runState.gate_results.length - 1];
+        console.log(`
+Gate: ${lastGate.summary}`);
+        for (const check2 of lastGate.checks) {
+          const icon = check2.passed ? "\x1B[32m✓\x1B[0m" : "\x1B[31m✗\x1B[0m";
+          console.log(`  ${icon} ${check2.name}`);
+        }
+      }
+    }
+    if (runState.status !== "gate_passed") {
+      process.exit(1);
+    }
   } else {
-    console.log(`\x1B[1movernight: Running ${configs.length} jobs...\x1B[0m`);
-  }
-  if (security && !opts.quiet) {
-    console.log("\x1B[2mSecurity:\x1B[0m");
-    validateSecurityConfig(security);
-  }
-  console.log("");
-  const log = opts.quiet ? undefined : (msg) => console.log(msg);
-  const startTime = Date.now();
-  const reloadConfigs = () => parseTasksFile(tasksFile, cliSecurity).configs;
-  const results = await runJobsWithState(configs, {
-    stateFile: opts.stateFile,
-    log,
-    reloadConfigs
-  });
-  const totalDuration = (Date.now() - startTime) / 1000;
-  if (opts.notify) {
-    const success = await sendNtfyNotification(results, totalDuration, opts.notifyTopic);
-    if (success) {
-      console.log(`\x1B[2mNotification sent to ntfy.sh/${opts.notifyTopic}\x1B[0m`);
+    const cliSecurity = opts.security === false ? undefined : {
+      ...opts.sandbox && { sandbox_dir: opts.sandbox },
+      ...opts.maxTurns && { max_turns: parseInt(opts.maxTurns, 10) },
+      ...opts.auditLog && { audit_log: opts.auditLog }
+    };
+    const { configs, security } = parseTasksFile(inputFile, cliSecurity);
+    if (configs.length === 0) {
+      console.error("No tasks found in file");
+      process.exit(1);
+    }
+    const existingState = loadState(opts.stateFile ?? DEFAULT_STATE_FILE);
+    if (existingState) {
+      const done = Object.keys(existingState.completed).length;
+      const pending = configs.filter((c) => !(taskKey(c) in existingState.completed)).length;
+      console.log(`\x1B[1movernight: Resuming — ${done} done, ${pending} remaining\x1B[0m`);
+      console.log(`\x1B[2mLast checkpoint: ${existingState.timestamp}\x1B[0m`);
     } else {
-      console.log("\x1B[33mWarning: Failed to send notification\x1B[0m");
+      console.log(`\x1B[1movernight: Running ${configs.length} jobs...\x1B[0m`);
+    }
+    if (security && !opts.quiet) {
+      console.log("\x1B[2mSecurity:\x1B[0m");
+      validateSecurityConfig(security);
+    }
+    console.log("");
+    const log = opts.quiet ? undefined : (msg) => console.log(msg);
+    const startTime = Date.now();
+    const reloadConfigs = () => parseTasksFile(inputFile, cliSecurity).configs;
+    const results = await runJobsWithState(configs, {
+      stateFile: opts.stateFile,
+      log,
+      reloadConfigs
+    });
+    const totalDuration = (Date.now() - startTime) / 1000;
+    if (opts.notify) {
+      const success = await sendNtfyNotification(results, totalDuration, opts.notifyTopic);
+      if (success) {
+        console.log(`\x1B[2mNotification sent to ntfy.sh/${opts.notifyTopic}\x1B[0m`);
+      } else {
+        console.log("\x1B[33mWarning: Failed to send notification\x1B[0m");
+      }
     }
-  }
-  if (opts.report) {
-    generateReport(results, totalDuration, opts.report);
-    console.log(`\x1B[2mReport saved to ${opts.report}\x1B[0m`);
-  }
-  if (!opts.quiet) {
-    printSummary(results);
-  }
-  if (opts.output) {
-    writeFileSync3(opts.output, resultsToJson(results));
-    console.log(`
+    if (opts.report) {
+      generateReport(results, totalDuration, opts.report);
+      console.log(`\x1B[2mReport saved to ${opts.report}\x1B[0m`);
+    }
+    if (!opts.quiet) {
+      printSummary(results);
+    }
+    if (opts.output) {
+      writeFileSync5(opts.output, resultsToJson(results));
+      console.log(`
 \x1B[2mResults saved to ${opts.output}\x1B[0m`);
-  }
-  if (results.some((r) => r.status !== "success")) {
-    process.exit(1);
+    }
+    if (results.some((r) => r.status !== "success")) {
+      process.exit(1);
+    }
   }
 });
 program2.command("resume").description("Resume a previous run from saved state").argument("<tasks-file>", "Path to tasks.yaml file").option("-o, --output <file>", "Output file for results JSON").option("-q, --quiet", "Minimal output").option("-s, --state-file <file>", "Custom state file path").option("--notify", "Send push notification via ntfy.sh").option("--notify-topic <topic>", "ntfy.sh topic", DEFAULT_NTFY_TOPIC).option("-r, --report <file>", "Generate markdown report").option("--sandbox <dir>", "Sandbox directory (restrict file access)").option("--max-turns <n>", "Max agent iterations per task", String(DEFAULT_MAX_TURNS)).option("--audit-log <file>", "Audit log file path").option("--no-security", "Disable default security (deny patterns)").action(async (tasksFile, opts) => {
@@ -26441,7 +27335,7 @@ program2.command("resume").description("Resume a previous run from saved state")
     console.error("Run 'overnight run' first to start jobs.");
     process.exit(1);
   }
-  if (!existsSync5(tasksFile)) {
+  if (!existsSync7(tasksFile)) {
     console.error(`Error: File not found: ${tasksFile}`);
     process.exit(1);
   }
@@ -26489,7 +27383,7 @@ program2.command("resume").description("Resume a previous run from saved state")
     printSummary(results);
   }
   if (opts.output) {
-    writeFileSync3(opts.output, resultsToJson(results));
+    writeFileSync5(opts.output, resultsToJson(results));
     console.log(`
 \x1B[2mResults saved to ${opts.output}\x1B[0m`);
   }
@@ -26527,8 +27421,91 @@ program2.command("single").description("Run a single job directly").argument("<p
     process.exit(1);
   }
 });
-program2.command("init").description("Create an example tasks.yaml file").action(() => {
-  const example = `# overnight task file
+program2.command("hammer").description("Autonomous build loop from an inline goal string").argument("<goal>", "The goal to work toward").option("--max-iterations <n>", "Max build loop iterations", String(DEFAULT_MAX_ITERATIONS)).option("--max-turns <n>", "Max agent turns per iteration", String(DEFAULT_MAX_TURNS)).option("-t, --timeout <seconds>", "Timeout per iteration in seconds", "600").option("-T, --tools <tool...>", "Allowed tools").option("--sandbox <dir>", "Sandbox directory").option("-s, --state-file <file>", "Custom state file path").option("--notify", "Send push notification via ntfy.sh").option("--notify-topic <topic>", "ntfy.sh topic", DEFAULT_NTFY_TOPIC).option("-q, --quiet", "Minimal output").option("--no-security", "Disable default security").action(async (goalStr, opts) => {
+  const goal = {
+    goal: goalStr,
+    max_iterations: parseInt(opts.maxIterations, 10),
+    defaults: {
+      timeout_seconds: parseInt(opts.timeout, 10),
+      allowed_tools: opts.tools ?? [...DEFAULT_TOOLS, "Bash"],
+      security: opts.security === false ? undefined : {
+        ...opts.sandbox && { sandbox_dir: opts.sandbox },
+        max_turns: parseInt(opts.maxTurns, 10),
+        deny_patterns: DEFAULT_DENY_PATTERNS
+      }
+    }
+  };
+  const log = opts.quiet ? undefined : (msg) => console.log(msg);
+  const startTime = Date.now();
+  const runState = await runGoal(goal, {
+    stateFile: opts.stateFile ?? DEFAULT_GOAL_STATE_FILE,
+    log
+  });
+  const totalDuration = (Date.now() - startTime) / 1000;
+  if (opts.notify) {
+    const passed = runState.status === "gate_passed";
+    try {
+      await fetch(`https://ntfy.sh/${opts.notifyTopic ?? DEFAULT_NTFY_TOPIC}`, {
+        method: "POST",
+        headers: {
+          Title: passed ? `overnight: Goal completed (${runState.iterations.length} iterations)` : `overnight: ${runState.status} after ${runState.iterations.length} iterations`,
+          Priority: passed ? "default" : "high",
+          Tags: passed ? "white_check_mark" : "warning"
+        },
+        body: passed ? `Gate passed. ${runState.iterations.length} iterations.` : `Status: ${runState.status}. Check report for details.`
+      });
+      if (!opts.quiet)
+        console.log(`\x1B[2mNotification sent\x1B[0m`);
+    } catch {
+      if (!opts.quiet)
+        console.log("\x1B[33mWarning: Failed to send notification\x1B[0m");
+    }
+  }
+  if (!opts.quiet) {
+    console.log(`
+\x1B[1m━━━ Hammer Summary ━━━\x1B[0m`);
+    console.log(`Status: ${runState.status === "gate_passed" ? "\x1B[32m" : "\x1B[31m"}${runState.status}\x1B[0m`);
+    console.log(`Iterations: ${runState.iterations.length}`);
+    console.log(`Gate attempts: ${runState.gate_results.length}`);
+    let durationStr;
+    if (totalDuration >= 3600) {
+      const hours = Math.floor(totalDuration / 3600);
+      const mins = Math.floor(totalDuration % 3600 / 60);
+      durationStr = `${hours}h ${mins}m`;
+    } else if (totalDuration >= 60) {
+      const mins = Math.floor(totalDuration / 60);
+      const secs = Math.floor(totalDuration % 60);
+      durationStr = `${mins}m ${secs}s`;
+    } else {
+      durationStr = `${totalDuration.toFixed(1)}s`;
+    }
+    console.log(`Duration: ${durationStr}`);
+    if (runState.gate_results.length > 0) {
+      const lastGate = runState.gate_results[runState.gate_results.length - 1];
+      console.log(`
+Gate: ${lastGate.summary}`);
+      for (const check2 of lastGate.checks) {
+        const icon = check2.passed ? "\x1B[32m✓\x1B[0m" : "\x1B[31m✗\x1B[0m";
+        console.log(`  ${icon} ${check2.name}`);
+      }
+    }
+  }
+  if (runState.status !== "gate_passed") {
+    process.exit(1);
+  }
+});
+program2.command("plan").description("Interactive design session to create a goal.yaml").argument("<goal>", "High-level goal description").option("-o, --output <file>", "Output file path", "goal.yaml").action(async (goal, opts) => {
+  const result = await runPlanner(goal, {
+    outputFile: opts.output,
+    log: (msg) => console.log(msg)
+  });
+  if (!result) {
+    process.exit(1);
+  }
+});
+program2.command("init").description("Create an example goal.yaml or tasks.yaml").option("--tasks", "Create tasks.yaml instead of goal.yaml").action((opts) => {
+  if (opts.tasks) {
+    const example = `# overnight task file
 # Run with: overnight run tasks.yaml
 
 defaults:
@@ -26548,9 +27525,6 @@ defaults:
     sandbox_dir: "."      # Restrict to current directory
     max_turns: 100        # Prevent runaway agents
     # audit_log: "overnight-audit.log"  # Uncomment to enable
-    # deny_patterns:       # Default patterns block .env, .key, .pem, etc.
-    #   - "**/.env*"
-    #   - "**/*.key"
 
 tasks:
   # Simple string format
@@ -26572,12 +27546,62 @@ tasks:
       - Glob
       - Grep
 `;
-  if (existsSync5("tasks.yaml")) {
-    console.log("\x1B[33mtasks.yaml already exists\x1B[0m");
-    process.exit(1);
+    if (existsSync7("tasks.yaml")) {
+      console.log("\x1B[33mtasks.yaml already exists\x1B[0m");
+      process.exit(1);
+    }
+    writeFileSync5("tasks.yaml", example);
+    console.log("\x1B[32mCreated tasks.yaml\x1B[0m");
+    console.log("Edit the file, then run: \x1B[1movernight run tasks.yaml\x1B[0m");
+  } else {
+    const example = `# overnight goal file
+# Run with: overnight run goal.yaml
+#
+# Or use "overnight plan" for an interactive design session:
+#   overnight plan "Build a multiplayer game"
+
+goal: "Describe your project goal here"
+
+acceptance_criteria:
+  - "The project builds without errors"
+  - "All tests pass"
+  - "Core features are functional"
+
+verification_commands:
+  - "npm run build"
+  - "npm test"
+
+constraints:
+  - "Don't modify existing API contracts"
+  - "Keep dependencies minimal"
+
+# How many build iterations before stopping
+max_iterations: 15
+
+# Stop if remaining items don't shrink for this many iterations
+convergence_threshold: 3
+
+defaults:
+  timeout_seconds: 600    # 10 minutes per iteration
+  allowed_tools:
+    - Read
+    - Edit
+    - Write
+    - Glob
+    - Grep
+    - Bash
+  security:
+    sandbox_dir: "."
+    max_turns: 150
+`;
+    if (existsSync7("goal.yaml")) {
+      console.log("\x1B[33mgoal.yaml already exists\x1B[0m");
+      process.exit(1);
+    }
+    writeFileSync5("goal.yaml", example);
+    console.log("\x1B[32mCreated goal.yaml\x1B[0m");
+    console.log("Edit the file, then run: \x1B[1movernight run goal.yaml\x1B[0m");
+    console.log(`\x1B[2mTip: Use 'overnight plan "your goal"' for an interactive design session\x1B[0m`);
   }
-  writeFileSync3("tasks.yaml", example);
-  console.log("\x1B[32mCreated tasks.yaml\x1B[0m");
-  console.log("Edit the file, then run: \x1B[1movernight run tasks.yaml\x1B[0m");
 });
 program2.parse();