@yail259/overnight 0.1.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"];
@@ -8831,9 +8835,145 @@ var DEFAULT_TIMEOUT = 300;
 var DEFAULT_STALL_TIMEOUT = 120;
 var DEFAULT_RETRY_COUNT = 3;
 var DEFAULT_RETRY_DELAY = 5;
-var DEFAULT_VERIFY_PROMPT = "Verify this is complete and correct. If there are issues, list them.";
+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.*",
+  "**/.git/config",
+  "**/credentials*",
+  "**/*.key",
+  "**/*.pem",
+  "**/*.p12",
+  "**/id_rsa*",
+  "**/id_ed25519*",
+  "**/.ssh/*",
+  "**/.aws/*",
+  "**/.npmrc",
+  "**/.netrc"
+];
+
+// src/security.ts
+import { appendFileSync } from "fs";
+import { resolve, relative, isAbsolute } from "path";
+function matchesPattern(filePath, pattern) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*");
+  if (!pattern.startsWith("/")) {
+    regex = `(^|/)${regex}`;
+  }
+  return new RegExp(regex + "$").test(normalizedPath);
+}
+function isPathWithinSandbox(filePath, sandboxDir) {
+  const absolutePath = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
+  const absoluteSandbox = isAbsolute(sandboxDir) ? sandboxDir : resolve(process.cwd(), sandboxDir);
+  const relativePath = relative(absoluteSandbox, absolutePath);
+  return !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function isPathDenied(filePath, denyPatterns) {
+  for (const pattern of denyPatterns) {
+    if (matchesPattern(filePath, pattern)) {
+      return pattern;
+    }
+  }
+  return null;
+}
+function createSecurityHooks(config) {
+  const sandboxDir = config.sandbox_dir;
+  const denyPatterns = config.deny_patterns ?? DEFAULT_DENY_PATTERNS;
+  const auditLog = config.audit_log;
+  const preToolUseHook = async (input, _toolUseId, _context) => {
+    const hookEventName = input.hook_event_name;
+    if (hookEventName !== "PreToolUse")
+      return {};
+    const toolName = input.tool_name;
+    const toolInput = input.tool_input;
+    let filePath;
+    if (toolName === "Read" || toolName === "Write" || toolName === "Edit") {
+      filePath = toolInput.file_path;
+    } else if (toolName === "Glob" || toolName === "Grep") {
+      filePath = toolInput.path;
+    } else if (toolName === "Bash") {
+      const command = toolInput.command;
+      if (auditLog) {
+        const timestamp = new Date().toISOString();
+        appendFileSync(auditLog, `${timestamp} [BASH] ${command}
+`);
+      }
+      return {};
+    }
+    if (!filePath)
+      return {};
+    if (sandboxDir && !isPathWithinSandbox(filePath, sandboxDir)) {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "deny",
+          permissionDecisionReason: `Path "${filePath}" is outside sandbox directory "${sandboxDir}"`
+        }
+      };
+    }
+    const matchedPattern = isPathDenied(filePath, denyPatterns);
+    if (matchedPattern) {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "deny",
+          permissionDecisionReason: `Path "${filePath}" matches deny pattern "${matchedPattern}"`
+        }
+      };
+    }
+    return {};
+  };
+  const postToolUseHook = async (input, _toolUseId, _context) => {
+    if (!auditLog)
+      return {};
+    const hookEventName = input.hook_event_name;
+    if (hookEventName !== "PostToolUse")
+      return {};
+    const toolName = input.tool_name;
+    const toolInput = input.tool_input;
+    const timestamp = new Date().toISOString();
+    let logEntry = `${timestamp} [${toolName}]`;
+    if (toolName === "Read" || toolName === "Write" || toolName === "Edit") {
+      logEntry += ` ${toolInput.file_path}`;
+    } else if (toolName === "Glob") {
+      logEntry += ` pattern=${toolInput.pattern} path=${toolInput.path ?? "."}`;
+    } else if (toolName === "Grep") {
+      logEntry += ` pattern=${toolInput.pattern}`;
+    }
+    appendFileSync(auditLog, logEntry + `
+`);
+    return {};
+  };
+  return {
+    PreToolUse: [
+      { matcher: "Read|Write|Edit|Glob|Grep|Bash", hooks: [preToolUseHook] }
+    ],
+    PostToolUse: [
+      { matcher: "Read|Write|Edit|Glob|Grep|Bash", hooks: [postToolUseHook] }
+    ]
+  };
+}
+function validateSecurityConfig(config) {
+  if (config.sandbox_dir) {
+    const resolved = isAbsolute(config.sandbox_dir) ? config.sandbox_dir : resolve(process.cwd(), config.sandbox_dir);
+    console.log(`  Sandbox: ${resolved}`);
+  }
+  const denyPatterns = config.deny_patterns ?? DEFAULT_DENY_PATTERNS;
+  console.log(`  Deny patterns: ${denyPatterns.length} patterns`);
+  if (config.max_turns) {
+    console.log(`  Max turns: ${config.max_turns}`);
+  }
+  if (config.audit_log) {
+    console.log(`  Audit log: ${config.audit_log}`);
+  }
+}
 
 // node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 import { join as join5 } from "path";
@@ -8850,7 +8990,7 @@ import { cwd } from "process";
 import { realpathSync as realpathSync2 } from "fs";
 import { randomUUID } from "crypto";
 import { randomUUID as randomUUID2 } from "crypto";
-import { appendFileSync as appendFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { appendFileSync as appendFileSync22, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
 import { join as join3 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var __create2 = Object.create;
@@ -11724,7 +11864,7 @@ var require_compile = __commonJS2((exports) => {
     const schOrFunc = root2.refs[ref];
     if (schOrFunc)
       return schOrFunc;
-    let _sch = resolve.call(this, root2, ref);
+    let _sch = resolve2.call(this, root2, ref);
     if (_sch === undefined) {
       const schema = (_a = root2.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
@@ -11751,7 +11891,7 @@ var require_compile = __commonJS2((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve(root2, ref) {
+  function resolve2(root2, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string")
       ref = sch;
@@ -12249,54 +12389,54 @@ var require_fast_uri = __commonJS2((exports, module) => {
     }
     return uri;
   }
-  function resolve(baseURI, relativeURI, options) {
+  function resolve2(baseURI, relativeURI, options) {
     const schemelessOptions = Object.assign({ scheme: "null" }, options);
     const resolved = resolveComponents(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
     return serialize(resolved, { ...schemelessOptions, skipEscape: true });
   }
-  function resolveComponents(base, relative, options, skipNormalization) {
+  function resolveComponents(base, relative2, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse6(serialize(base, options), options);
-      relative = parse6(serialize(relative, options), options);
+      relative2 = parse6(serialize(relative2, options), options);
     }
     options = options || {};
-    if (!options.tolerant && relative.scheme) {
-      target.scheme = relative.scheme;
-      target.userinfo = relative.userinfo;
-      target.host = relative.host;
-      target.port = relative.port;
-      target.path = removeDotSegments(relative.path || "");
-      target.query = relative.query;
+    if (!options.tolerant && relative2.scheme) {
+      target.scheme = relative2.scheme;
+      target.userinfo = relative2.userinfo;
+      target.host = relative2.host;
+      target.port = relative2.port;
+      target.path = removeDotSegments(relative2.path || "");
+      target.query = relative2.query;
     } else {
-      if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
-        target.userinfo = relative.userinfo;
-        target.host = relative.host;
-        target.port = relative.port;
-        target.path = removeDotSegments(relative.path || "");
-        target.query = relative.query;
+      if (relative2.userinfo !== undefined || relative2.host !== undefined || relative2.port !== undefined) {
+        target.userinfo = relative2.userinfo;
+        target.host = relative2.host;
+        target.port = relative2.port;
+        target.path = removeDotSegments(relative2.path || "");
+        target.query = relative2.query;
       } else {
-        if (!relative.path) {
+        if (!relative2.path) {
           target.path = base.path;
-          if (relative.query !== undefined) {
-            target.query = relative.query;
+          if (relative2.query !== undefined) {
+            target.query = relative2.query;
           } else {
             target.query = base.query;
           }
         } else {
-          if (relative.path.charAt(0) === "/") {
-            target.path = removeDotSegments(relative.path);
+          if (relative2.path.charAt(0) === "/") {
+            target.path = removeDotSegments(relative2.path);
           } else {
             if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
-              target.path = "/" + relative.path;
+              target.path = "/" + relative2.path;
             } else if (!base.path) {
-              target.path = relative.path;
+              target.path = relative2.path;
             } else {
-              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative2.path;
             }
             target.path = removeDotSegments(target.path);
           }
-          target.query = relative.query;
+          target.query = relative2.query;
         }
         target.userinfo = base.userinfo;
         target.host = base.host;
@@ -12304,7 +12444,7 @@ var require_fast_uri = __commonJS2((exports, module) => {
       }
       target.scheme = base.scheme;
     }
-    target.fragment = relative.fragment;
+    target.fragment = relative2.fragment;
     return target;
   }
   function equal(uriA, uriB, options) {
@@ -12482,7 +12622,7 @@ var require_fast_uri = __commonJS2((exports, module) => {
   var fastUri = {
     SCHEMES,
     normalize,
-    resolve,
+    resolve: resolve2,
     resolveComponents,
     equal,
     serialize,
@@ -15144,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();
@@ -16072,7 +16212,7 @@ function logForSdkDebugging(message) {
   const timestamp = new Date().toISOString();
   const output = `${timestamp} ${message}
 `;
-  appendFileSync2(path, output);
+  appendFileSync22(path, output);
 }
 function mergeSandboxIntoExtraArgs(extraArgs, sandbox) {
   const effectiveExtraArgs = { ...extraArgs };
@@ -16474,7 +16614,7 @@ class ProcessTransport {
       }
       return;
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const exitHandler = (code, signal) => {
         if (this.abortController.signal.aborted) {
           reject(new AbortError("Operation aborted"));
@@ -16484,7 +16624,7 @@ class ProcessTransport {
         if (error) {
           reject(error);
         } else {
-          resolve();
+          resolve2();
         }
       };
       this.process.once("exit", exitHandler);
@@ -16535,17 +16675,17 @@ class Stream {
     if (this.hasError) {
       return Promise.reject(this.hasError);
     }
-    return new Promise((resolve, reject) => {
-      this.readResolve = resolve;
+    return new Promise((resolve2, reject) => {
+      this.readResolve = resolve2;
       this.readReject = reject;
     });
   }
   enqueue(value) {
     if (this.readResolve) {
-      const resolve = this.readResolve;
+      const resolve2 = this.readResolve;
       this.readResolve = undefined;
       this.readReject = undefined;
-      resolve({ done: false, value });
+      resolve2({ done: false, value });
     } else {
       this.queue.push(value);
     }
@@ -16553,10 +16693,10 @@ class Stream {
   done() {
     this.isDone = true;
     if (this.readResolve) {
-      const resolve = this.readResolve;
+      const resolve2 = this.readResolve;
       this.readResolve = undefined;
       this.readReject = undefined;
-      resolve({ done: true, value: undefined });
+      resolve2({ done: true, value: undefined });
     }
   }
   error(error) {
@@ -16886,10 +17026,10 @@ class Query {
       type: "control_request",
       request
     };
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this.pendingControlResponses.set(requestId, (response) => {
         if (response.subtype === "success") {
-          resolve(response);
+          resolve2(response);
         } else {
           reject(new Error(response.error));
           if (response.pending_permission_requests) {
@@ -16979,15 +17119,15 @@ class Query {
       logForDebugging(`[Query.waitForFirstResult] Result already received, returning immediately`);
       return Promise.resolve();
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       if (this.abortController?.signal.aborted) {
-        resolve();
+        resolve2();
         return;
       }
-      this.abortController?.signal.addEventListener("abort", () => resolve(), {
+      this.abortController?.signal.addEventListener("abort", () => resolve2(), {
         once: true
       });
-      this.firstResultReceivedResolve = resolve;
+      this.firstResultReceivedResolve = resolve2;
     });
   }
   handleHookCallbacks(callbackId, input, toolUseID, abortSignal) {
@@ -17038,13 +17178,13 @@ class Query {
   handleMcpControlRequest(serverName, mcpRequest, transport) {
     const messageId = "id" in mcpRequest.message ? mcpRequest.message.id : null;
     const key = `${serverName}:${messageId}`;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const cleanup = () => {
         this.pendingMcpResponses.delete(key);
       };
       const resolveAndCleanup = (response) => {
         cleanup();
-        resolve(response);
+        resolve2(response);
       };
       const rejectAndCleanup = (error) => {
         cleanup();
@@ -25296,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) {
@@ -25452,6 +25592,78 @@ function query({
 
 // src/runner.ts
 import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3, unlinkSync as unlinkSync2 } from "fs";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+var SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+class ProgressDisplay {
+  interval = null;
+  frame = 0;
+  startTime = Date.now();
+  currentActivity = "Working";
+  lastToolUse = "";
+  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);
+      const toolInfo = this.lastToolUse ? ` → ${this.lastToolUse}` : "";
+      process.stdout.write(`\r\x1B[K${SPINNER_FRAMES[this.frame]} ${this.currentActivity} (${elapsed}s)${toolInfo}`);
+      this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+    }, 100);
+  }
+  updateActivity(activity) {
+    this.currentActivity = activity;
+  }
+  updateTool(toolName, detail) {
+    this.lastToolUse = detail ? `${toolName}: ${detail}` : toolName;
+  }
+  stop(finalMessage) {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    process.stdout.write("\r\x1B[K");
+    if (finalMessage) {
+      console.log(finalMessage);
+    }
+  }
+  getElapsed() {
+    return (Date.now() - this.startTime) / 1000;
+  }
+}
+var claudeExecutablePath;
+function findClaudeExecutable() {
+  if (claudeExecutablePath !== undefined)
+    return claudeExecutablePath;
+  if (process.env.CLAUDE_CODE_PATH) {
+    claudeExecutablePath = process.env.CLAUDE_CODE_PATH;
+    return claudeExecutablePath;
+  }
+  try {
+    const cmd = process.platform === "win32" ? "where claude" : "which claude";
+    claudeExecutablePath = execSync(cmd, { encoding: "utf-8" }).trim().split(`
+`)[0];
+    return claudeExecutablePath;
+  } catch {
+    const commonPaths = [
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+      `${process.env.HOME}/.local/bin/claude`,
+      `${process.env.HOME}/.nvm/versions/node/v22.12.0/bin/claude`
+    ];
+    for (const p of commonPaths) {
+      if (existsSync3(p)) {
+        claudeExecutablePath = p;
+        return claudeExecutablePath;
+      }
+    }
+  }
+  return;
+}
 function isRetryableError(error2) {
   const errorStr = error2.message.toLowerCase();
   const retryablePatterns = [
@@ -25469,7 +25681,7 @@ function isRetryableError(error2) {
   return retryablePatterns.some((pattern) => errorStr.includes(pattern));
 }
 async function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function runWithTimeout(promise, timeoutMs) {
   let timeoutId;
@@ -25485,19 +25697,71 @@ async function runWithTimeout(promise, timeoutMs) {
     throw e;
   }
 }
-async function collectResult(prompt, options) {
+function getToolDetail(toolName, toolInput) {
+  switch (toolName) {
+    case "Read":
+    case "Write":
+    case "Edit":
+      const filePath = toolInput.file_path;
+      if (filePath) {
+        return filePath.split("/").pop() || filePath;
+      }
+      break;
+    case "Glob":
+      return toolInput.pattern || "";
+    case "Grep":
+      return toolInput.pattern?.slice(0, 20) || "";
+    case "Bash":
+      const cmd = toolInput.command || "";
+      return cmd.slice(0, 30) + (cmd.length > 30 ? "..." : "");
+  }
+  return "";
+}
+async function collectResultWithProgress(prompt, options, progress, onSessionId) {
   let sessionId;
   let result;
-  const conversation = query({ prompt, options });
-  for await (const message of conversation) {
-    if (message.type === "result") {
-      result = message.result;
-      sessionId = message.session_id;
+  let lastError;
+  try {
+    const conversation = query({ prompt, options });
+    for await (const message of conversation) {
+      if (process.env.OVERNIGHT_DEBUG) {
+        console.error(`
+[DEBUG] message.type=${message.type}, keys=${Object.keys(message).join(",")}`);
+      }
+      if (message.type === "result") {
+        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) {
+          for (const block of assistantMsg.content) {
+            if (process.env.OVERNIGHT_DEBUG) {
+              console.error(`[DEBUG] content block: type=${block.type}, name=${block.name}`);
+            }
+            if (block.type === "tool_use" && block.name) {
+              const detail = block.input ? getToolDetail(block.name, block.input) : "";
+              progress.updateTool(block.name, detail);
+            }
+          }
+        }
+      } else if (message.type === "system" && "subtype" in message) {
+        if (message.subtype === "init") {
+          sessionId = message.session_id;
+          if (sessionId && onSessionId) {
+            onSessionId(sessionId);
+          }
+        }
+      }
     }
+  } catch (e) {
+    lastError = e.message;
+    throw e;
   }
-  return { sessionId, result };
+  return { sessionId, result, error: lastError };
 }
-async function runJob(config2, log) {
+async function runJob(config2, log, options) {
   const startTime = Date.now();
   const tools = config2.allowed_tools ?? DEFAULT_TOOLS;
   const timeout = (config2.timeout_seconds ?? DEFAULT_TIMEOUT) * 1000;
@@ -25505,31 +25769,71 @@ async function runJob(config2, log) {
   const retryDelay = config2.retry_delay ?? DEFAULT_RETRY_DELAY;
   const verifyPrompt = config2.verify_prompt ?? DEFAULT_VERIFY_PROMPT;
   let retriesUsed = 0;
+  let resumeSessionId = options?.resumeSessionId;
   const logMsg = (msg) => log?.(msg);
-  logMsg(`Starting: ${config2.prompt.slice(0, 60)}...`);
+  const progress = new ProgressDisplay;
+  const claudePath = findClaudeExecutable();
+  if (!claudePath) {
+    logMsg("\x1B[31m✗ Error: Could not find 'claude' CLI.\x1B[0m");
+    logMsg("\x1B[33m  Install it with:\x1B[0m");
+    logMsg("    curl -fsSL https://claude.ai/install.sh | bash");
+    logMsg("\x1B[33m  Or set CLAUDE_CODE_PATH environment variable.\x1B[0m");
+    return {
+      task: config2.prompt,
+      status: "failed",
+      error: "Claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash",
+      duration_seconds: 0,
+      verified: false,
+      retries: 0
+    };
+  }
+  if (process.env.OVERNIGHT_DEBUG) {
+    logMsg(`\x1B[2mDebug: Claude path = ${claudePath}\x1B[0m`);
+  }
+  const taskPreview = config2.prompt.slice(0, 60) + (config2.prompt.length > 60 ? "..." : "");
+  if (resumeSessionId) {
+    logMsg(`\x1B[36m▶\x1B[0m Resuming: ${taskPreview}`);
+  } else {
+    logMsg(`\x1B[36m▶\x1B[0m ${taskPreview}`);
+  }
+  let sessionId;
   for (let attempt = 0;attempt <= retryCount; attempt++) {
     try {
-      const options = {
+      const securityHooks = config2.security ? createSecurityHooks(config2.security) : undefined;
+      const sdkOptions = {
         allowedTools: tools,
         permissionMode: "acceptEdits",
-        ...config2.working_dir && { cwd: config2.working_dir }
+        ...claudePath && { pathToClaudeCodeExecutable: claudePath },
+        ...config2.working_dir && { cwd: config2.working_dir },
+        ...config2.security?.max_turns && { maxTurns: config2.security.max_turns },
+        ...securityHooks && { hooks: securityHooks },
+        ...resumeSessionId && { resume: resumeSessionId }
       };
-      let sessionId;
       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(collectResult(config2.prompt, options), timeout);
+        const collected = await runWithTimeout(collectResultWithProgress(prompt, sdkOptions, progress, (id) => {
+          sessionId = id;
+          options?.onSessionId?.(id);
+        }), timeout);
         sessionId = collected.sessionId;
         result = collected.result;
+        progress.stop();
       } catch (e) {
+        progress.stop();
         if (e.message === "TIMEOUT") {
           if (attempt < retryCount) {
             retriesUsed = attempt + 1;
+            if (sessionId) {
+              resumeSessionId = sessionId;
+            }
             const delay = retryDelay * Math.pow(2, attempt);
-            logMsg(`Timeout after ${config2.timeout_seconds ?? DEFAULT_TIMEOUT}s, retrying in ${delay}s (attempt ${attempt + 1}/${retryCount})...`);
+            logMsg(`\x1B[33m⚠ Timeout after ${config2.timeout_seconds ?? DEFAULT_TIMEOUT}s, retrying in ${delay}s (${attempt + 1}/${retryCount})\x1B[0m`);
             await sleep(delay * 1000);
             continue;
           }
-          logMsg(`Timeout after ${config2.timeout_seconds ?? DEFAULT_TIMEOUT}s (exhausted retries)`);
+          logMsg(`\x1B[31m✗ Timeout after ${config2.timeout_seconds ?? DEFAULT_TIMEOUT}s (exhausted retries)\x1B[0m`);
           return {
             task: config2.prompt,
             status: "timeout",
@@ -25542,36 +25846,49 @@ async function runJob(config2, log) {
         throw e;
       }
       if (config2.verify !== false && sessionId) {
-        logMsg("Running verification...");
+        progress.start("Verifying");
         const verifyOptions = {
+          allowedTools: tools,
           resume: sessionId,
-          permissionMode: "acceptEdits"
+          permissionMode: "acceptEdits",
+          ...claudePath && { pathToClaudeCodeExecutable: claudePath },
+          ...config2.working_dir && { cwd: config2.working_dir },
+          ...config2.security?.max_turns && { maxTurns: config2.security.max_turns }
         };
+        const fixPrompt = verifyPrompt + " If you find any issues, fix them now. Only report issues you cannot fix.";
         try {
-          const verifyResult = await runWithTimeout(collectResult(verifyPrompt, verifyOptions), timeout / 2);
-          const issueWords = ["issue", "error", "fail", "incorrect", "missing"];
-          if (verifyResult.result && issueWords.some((word) => verifyResult.result.toLowerCase().includes(word))) {
-            logMsg("Verification found potential issues");
+          const verifyResult = await runWithTimeout(collectResultWithProgress(fixPrompt, verifyOptions, progress, (id) => {
+            sessionId = id;
+            options?.onSessionId?.(id);
+          }), timeout / 2);
+          progress.stop();
+          if (verifyResult.result) {
+            result = verifyResult.result;
+          }
+          const unfixableWords = ["cannot fix", "unable to", "blocked by", "requires manual"];
+          if (verifyResult.result && unfixableWords.some((word) => verifyResult.result.toLowerCase().includes(word))) {
+            logMsg(`\x1B[33m⚠ Verification found unfixable issues\x1B[0m`);
             return {
               task: config2.prompt,
               status: "verification_failed",
               result,
-              error: `Verification issues: ${verifyResult.result}`,
+              error: `Unfixable issues: ${verifyResult.result}`,
               duration_seconds: (Date.now() - startTime) / 1000,
               verified: false,
               retries: retriesUsed
             };
           }
         } catch (e) {
+          progress.stop();
           if (e.message === "TIMEOUT") {
-            logMsg("Verification timed out - continuing anyway");
+            logMsg("\x1B[33m⚠ Verification timed out - continuing anyway\x1B[0m");
           } else {
             throw e;
           }
         }
       }
       const duration3 = (Date.now() - startTime) / 1000;
-      logMsg(`Completed in ${duration3.toFixed(1)}s`);
+      logMsg(`\x1B[32m✓ Completed in ${duration3.toFixed(1)}s\x1B[0m`);
       return {
         task: config2.prompt,
         status: "success",
@@ -25581,16 +25898,20 @@ async function runJob(config2, log) {
         retries: retriesUsed
       };
     } catch (e) {
+      progress.stop();
       const error2 = e;
       if (isRetryableError(error2) && attempt < retryCount) {
         retriesUsed = attempt + 1;
+        if (sessionId) {
+          resumeSessionId = sessionId;
+        }
         const delay = retryDelay * Math.pow(2, attempt);
-        logMsg(`Retryable error: ${error2.message}, retrying in ${delay}s (attempt ${attempt + 1}/${retryCount})...`);
+        logMsg(`\x1B[33m⚠ ${error2.message}, retrying in ${delay}s (${attempt + 1}/${retryCount})\x1B[0m`);
         await sleep(delay * 1000);
         continue;
       }
       const duration3 = (Date.now() - startTime) / 1000;
-      logMsg(`Failed: ${error2.message}`);
+      logMsg(`\x1B[31m✗ Failed: ${error2.message}\x1B[0m`);
       return {
         task: config2.prompt,
         status: "failed",
@@ -25610,6 +25931,56 @@ async function runJob(config2, log) {
     retries: retriesUsed
   };
 }
+function taskKey(config2) {
+  if (config2.id)
+    return config2.id;
+  return createHash("sha256").update(config2.prompt).digest("hex").slice(0, 12);
+}
+function validateDag(configs) {
+  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)) {
+        return `Task "${c.id ?? c.prompt.slice(0, 40)}" depends on unknown id "${dep}"`;
+      }
+    }
+  }
+  const visited = new Set;
+  const inStack = new Set;
+  const idToConfig = new Map(configs.filter((c) => c.id).map((c) => [c.id, c]));
+  function hasCycle(id) {
+    if (inStack.has(id))
+      return true;
+    if (visited.has(id))
+      return false;
+    visited.add(id);
+    inStack.add(id);
+    const config2 = idToConfig.get(id);
+    for (const dep of config2?.depends_on ?? []) {
+      if (hasCycle(dep))
+        return true;
+    }
+    inStack.delete(id);
+    return false;
+  }
+  for (const id of ids) {
+    if (hasCycle(id))
+      return `Dependency cycle detected involving "${id}"`;
+  }
+  return null;
+}
+function depsReady(config2, completed) {
+  if (!config2.depends_on || config2.depends_on.length === 0)
+    return "ready";
+  for (const dep of config2.depends_on) {
+    const result = completed[dep];
+    if (!result)
+      return "waiting";
+    if (result.status !== "success")
+      return "blocked";
+  }
+  return "ready";
+}
 function saveState(state, stateFile) {
   writeFileSync(stateFile, JSON.stringify(state, null, 2));
 }
@@ -25624,26 +25995,84 @@ function clearState(stateFile) {
 }
 async function runJobsWithState(configs, options = {}) {
   const stateFile = options.stateFile ?? DEFAULT_STATE_FILE;
-  const results = options.priorResults ? [...options.priorResults] : [];
-  const startIndex = options.startIndex ?? 0;
-  for (let i = 0;i < configs.length; i++) {
-    if (i < startIndex)
-      continue;
+  const dagError = validateDag(configs);
+  if (dagError) {
+    options.log?.(`\x1B[31m✗ DAG error: ${dagError}\x1B[0m`);
+    return [];
+  }
+  const state = loadState(stateFile) ?? {
+    completed: {},
+    timestamp: new Date().toISOString()
+  };
+  let currentConfigs = configs;
+  while (true) {
+    const notDone = currentConfigs.filter((c) => !(taskKey(c) in state.completed));
+    if (notDone.length === 0)
+      break;
+    const ready = notDone.filter((c) => depsReady(c, state.completed) === "ready");
+    const blocked = notDone.filter((c) => depsReady(c, state.completed) === "blocked");
+    for (const bc of blocked) {
+      const key2 = taskKey(bc);
+      if (key2 in state.completed)
+        continue;
+      const failedDeps = (bc.depends_on ?? []).filter((dep) => state.completed[dep] && state.completed[dep].status !== "success");
+      const label2 = bc.id ?? bc.prompt.slice(0, 40);
+      options.log?.(`
+\x1B[31m✗ Skipping "${label2}" — dependency failed: ${failedDeps.join(", ")}\x1B[0m`);
+      state.completed[key2] = {
+        task: bc.prompt,
+        status: "failed",
+        error: `Blocked by failed dependencies: ${failedDeps.join(", ")}`,
+        duration_seconds: 0,
+        verified: false,
+        retries: 0
+      };
+      state.timestamp = new Date().toISOString();
+      saveState(state, stateFile);
+    }
+    if (ready.length === 0)
+      break;
+    const config2 = ready[0];
+    const key = taskKey(config2);
+    const totalNotDone = notDone.length - blocked.length;
+    const totalDone = Object.keys(state.completed).length;
+    const label = config2.id ? `${config2.id}` : "";
     options.log?.(`
-[${i + 1}/${configs.length}] Running job...`);
-    const result = await runJob(configs[i], options.log);
-    results.push(result);
-    const state = {
-      completed_indices: Array.from({ length: results.length }, (_, i2) => i2),
-      results,
-      timestamp: new Date().toISOString(),
-      total_jobs: configs.length
-    };
+\x1B[1m[${totalDone + 1}/${totalDone + totalNotDone}]${label ? ` ${label}` : ""}\x1B[0m`);
+    const resumeSessionId = state.inProgress?.hash === key ? state.inProgress.sessionId : undefined;
+    if (resumeSessionId) {
+      options.log?.(`\x1B[2mResuming session ${resumeSessionId.slice(0, 8)}...\x1B[0m`);
+    }
+    state.inProgress = { hash: key, prompt: config2.prompt, startedAt: new Date().toISOString() };
+    saveState(state, stateFile);
+    const result = await runJob(config2, options.log, {
+      resumeSessionId,
+      onSessionId: (id) => {
+        state.inProgress = { hash: key, prompt: config2.prompt, sessionId: id, startedAt: state.inProgress.startedAt };
+        saveState(state, stateFile);
+      }
+    });
+    state.completed[key] = result;
+    state.inProgress = undefined;
+    state.timestamp = new Date().toISOString();
     saveState(state, stateFile);
-    if (i < configs.length - 1) {
+    if (options.reloadConfigs) {
+      try {
+        currentConfigs = options.reloadConfigs();
+        const newDagError = validateDag(currentConfigs);
+        if (newDagError) {
+          options.log?.(`\x1B[33m⚠ DAG error in updated YAML, ignoring reload: ${newDagError}\x1B[0m`);
+          currentConfigs = configs;
+        }
+      } catch {}
+    }
+    const nextNotDone = currentConfigs.filter((c) => !(taskKey(c) in state.completed));
+    const nextReady = nextNotDone.filter((c) => depsReady(c, state.completed) === "ready");
+    if (nextReady.length > 0) {
       await sleep(1000);
     }
   }
+  const results = currentConfigs.map((c) => state.completed[taskKey(c)]).filter((r) => r !== undefined);
   clearState(stateFile);
   return results;
 }
@@ -25778,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"
+
+verification_commands:
+  - "npm run build"
+  - "npm test"
+
+constraints:
+  - "Use vanilla JS, no frameworks"
+
+max_iterations: 15
+\`\`\`
+
+## Task Mode (tasks.yaml)
 
-## tasks.yaml Format
+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
@@ -25836,53 +27070,71 @@ 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 parseTasksFile(path) {
-  const content = readFileSync3(path, "utf-8");
-  const data = $parse(content);
+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 = readFileSync5(path, "utf-8");
+  let data;
+  try {
+    data = import_yaml2.parse(content);
+  } catch (e) {
+    const error2 = e;
+    console.error(`\x1B[31mError parsing ${path}:\x1B[0m`);
+    console.error(`  ${error2.message.split(`
+`)[0]}`);
+    process.exit(1);
+  }
   const tasks = Array.isArray(data) ? data : data.tasks ?? [];
   const defaults = Array.isArray(data) ? {} : data.defaults ?? {};
-  return tasks.map((task) => {
+  const fileSecurity = !Array.isArray(data) && data.defaults?.security || {};
+  const security = cliSecurity || Object.keys(fileSecurity).length > 0 ? {
+    ...fileSecurity,
+    ...cliSecurity,
+    deny_patterns: cliSecurity?.deny_patterns ?? fileSecurity.deny_patterns ?? DEFAULT_DENY_PATTERNS
+  } : undefined;
+  const configs = tasks.map((task) => {
     if (typeof task === "string") {
       return {
         prompt: task,
@@ -25890,19 +27142,24 @@ function parseTasksFile(path) {
         stall_timeout_seconds: defaults.stall_timeout_seconds ?? DEFAULT_STALL_TIMEOUT,
         verify: defaults.verify ?? true,
         verify_prompt: defaults.verify_prompt ?? DEFAULT_VERIFY_PROMPT,
-        allowed_tools: defaults.allowed_tools
+        allowed_tools: defaults.allowed_tools,
+        security
       };
     }
     return {
+      id: task.id ?? undefined,
+      depends_on: task.depends_on ?? undefined,
       prompt: task.prompt,
       working_dir: task.working_dir ?? undefined,
       timeout_seconds: task.timeout_seconds ?? defaults.timeout_seconds ?? DEFAULT_TIMEOUT,
       stall_timeout_seconds: task.stall_timeout_seconds ?? defaults.stall_timeout_seconds ?? DEFAULT_STALL_TIMEOUT,
       verify: task.verify ?? defaults.verify ?? true,
       verify_prompt: task.verify_prompt ?? defaults.verify_prompt ?? DEFAULT_VERIFY_PROMPT,
-      allowed_tools: task.allowed_tools ?? defaults.allowed_tools
+      allowed_tools: task.allowed_tools ?? defaults.allowed_tools,
+      security: task.security ?? security
     };
   });
+  return { configs, security };
 }
 function printSummary(results) {
   const statusColors = {
@@ -25928,53 +27185,149 @@ ${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.1.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").action(async (tasksFile, opts) => {
-  if (!existsSync5(tasksFile)) {
-    console.error(`Error: File not found: ${tasksFile}`);
-    process.exit(1);
-  }
-  const configs = parseTasksFile(tasksFile);
-  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);
   }
-  console.log(`\x1B[1movernight: Running ${configs.length} jobs...\x1B[0m
-`);
-  const log = opts.quiet ? undefined : (msg) => console.log(msg);
-  const startTime = Date.now();
-  const results = await runJobsWithState(configs, {
-    stateFile: opts.stateFile,
-    log
-  });
-  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`);
+  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 {
+    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").action(async (tasksFile, opts) => {
+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) => {
   const stateFile = opts.stateFile ?? DEFAULT_STATE_FILE;
   const state = loadState(stateFile);
   if (!state) {
@@ -25982,30 +27335,36 @@ 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);
   }
-  const configs = parseTasksFile(tasksFile);
+  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");
     process.exit(1);
   }
-  if (configs.length !== state.total_jobs) {
-    console.error(`Task file has ${configs.length} jobs but state has ${state.total_jobs}`);
-    process.exit(1);
+  const completedCount = Object.keys(state.completed).length;
+  const pendingCount = configs.filter((c) => !(taskKey(c) in state.completed)).length;
+  console.log(`\x1B[1movernight: Resuming — ${completedCount} done, ${pendingCount} remaining\x1B[0m`);
+  console.log(`\x1B[2mLast checkpoint: ${state.timestamp}\x1B[0m`);
+  if (security && !opts.quiet) {
+    console.log("\x1B[2mSecurity:\x1B[0m");
+    validateSecurityConfig(security);
   }
-  const startIndex = state.completed_indices.length;
-  console.log(`\x1B[1movernight: Resuming from job ${startIndex + 1}/${configs.length}...\x1B[0m`);
-  console.log(`\x1B[2mLast checkpoint: ${state.timestamp}\x1B[0m
-`);
+  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,
     log,
-    startIndex,
-    priorResults: state.results
+    reloadConfigs
   });
   const totalDuration = (Date.now() - startTime) / 1000;
   if (opts.notify) {
@@ -26024,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`);
   }
@@ -26032,12 +27391,18 @@ program2.command("resume").description("Resume a previous run from saved state")
     process.exit(1);
   }
 });
-program2.command("single").description("Run a single job directly").argument("<prompt>", "The task prompt").option("-t, --timeout <seconds>", "Timeout in seconds", "300").option("--verify", "Run verification pass", true).option("--no-verify", "Skip verification pass").option("-T, --tools <tool...>", "Allowed tools").action(async (prompt, opts) => {
+program2.command("single").description("Run a single job directly").argument("<prompt>", "The task prompt").option("-t, --timeout <seconds>", "Timeout in seconds", "300").option("--verify", "Run verification pass", true).option("--no-verify", "Skip verification pass").option("-T, --tools <tool...>", "Allowed tools").option("--sandbox <dir>", "Sandbox directory (restrict file access)").option("--max-turns <n>", "Max agent iterations", String(DEFAULT_MAX_TURNS)).option("--no-security", "Disable default security (deny patterns)").action(async (prompt, opts) => {
+  const security = opts.security === false ? undefined : {
+    ...opts.sandbox && { sandbox_dir: opts.sandbox },
+    ...opts.maxTurns && { max_turns: parseInt(opts.maxTurns, 10) },
+    deny_patterns: DEFAULT_DENY_PATTERNS
+  };
   const config2 = {
     prompt,
     timeout_seconds: parseInt(opts.timeout, 10),
     verify: opts.verify,
-    allowed_tools: opts.tools
+    allowed_tools: opts.tools,
+    security
   };
   const log = (msg) => console.log(msg);
   const result = await runJob(config2, log);
@@ -26056,13 +27421,97 @@ 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:
   timeout_seconds: 300  # 5 minutes per task
   verify: true          # Run verification after each task
+
   # Secure defaults - no Bash, just file operations
   allowed_tools:
     - Read
@@ -26071,6 +27520,12 @@ defaults:
     - Glob
     - Grep
 
+  # Security settings (optional - deny_patterns enabled by default)
+  security:
+    sandbox_dir: "."      # Restrict to current directory
+    max_turns: 100        # Prevent runaway agents
+    # audit_log: "overnight-audit.log"  # Uncomment to enable
+
 tasks:
   # Simple string format
   - "Find and fix any TODO comments in the codebase"
@@ -26091,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();