opencode-planpilot 0.2.2 → 0.2.4

package/dist/index.js

@@ -0,0 +1,3815 @@
+// src/index.ts
+import { tool } from "@opencode-ai/plugin";
+
+// src/command.ts
+import fs3 from "fs";
+
+// src/lib/db.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { Database } from "bun:sqlite";
+import { xdgConfig } from "xdg-basedir";
+var cachedDb = null;
+function resolveConfigRoot() {
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return process.env.OPENCODE_CONFIG_DIR;
+  }
+  const base = xdgConfig ?? path.join(os.homedir(), ".config");
+  return path.join(base, "opencode");
+}
+function resolvePlanpilotDir() {
+  const override = process.env.OPENCODE_PLANPILOT_DIR || process.env.OPENCODE_PLANPILOT_HOME;
+  if (override && override.trim()) return override;
+  return path.join(resolveConfigRoot(), ".planpilot");
+}
+function resolveDbPath() {
+  return path.join(resolvePlanpilotDir(), "planpilot.db");
+}
+function resolvePlanMarkdownDir() {
+  return path.join(resolvePlanpilotDir(), "plans");
+}
+function resolvePlanMarkdownPath(planId) {
+  return path.join(resolvePlanMarkdownDir(), `plan_${planId}.md`);
+}
+function ensureParentDir(filePath) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+}
+function openDatabase() {
+  if (cachedDb) return cachedDb;
+  const dbPath = resolveDbPath();
+  ensureParentDir(dbPath);
+  const db = new Database(dbPath);
+  db.exec("PRAGMA foreign_keys = ON;");
+  ensureSchema(db);
+  cachedDb = db;
+  return db;
+}
+function ensureSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS plans (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL,
+      comment TEXT,
+      last_session_id TEXT,
+      last_cwd TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS steps (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      plan_id INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL,
+      executor TEXT NOT NULL,
+      sort_order INTEGER NOT NULL,
+      comment TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(plan_id) REFERENCES plans(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS goals (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      step_id INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL,
+      comment TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(step_id) REFERENCES steps(id) ON DELETE CASCADE
+    );
+    CREATE TABLE IF NOT EXISTS active_plan (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      plan_id INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      UNIQUE(session_id),
+      UNIQUE(plan_id),
+      FOREIGN KEY(plan_id) REFERENCES plans(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_steps_plan_order ON steps(plan_id, sort_order);
+    CREATE INDEX IF NOT EXISTS idx_goals_step ON goals(step_id);
+  `);
+  const columns = db.prepare("PRAGMA table_info(plans)").all().map((row) => row.name);
+  if (!columns.includes("last_cwd")) {
+    db.exec("ALTER TABLE plans ADD COLUMN last_cwd TEXT");
+  }
+}
+
+// src/lib/models.ts
+function createEmptyStatusChanges() {
+  return { steps: [], plans: [], active_plans_cleared: [] };
+}
+function mergeStatusChanges(target, other) {
+  target.steps.push(...other.steps);
+  target.plans.push(...other.plans);
+  target.active_plans_cleared.push(...other.active_plans_cleared);
+}
+function statusChangesEmpty(changes) {
+  return !changes.steps.length && !changes.plans.length && !changes.active_plans_cleared.length;
+}
+
+// src/lib/util.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/lib/errors.ts
+var AppError = class extends Error {
+  kind;
+  detail;
+  constructor(kind, detail) {
+    super(detail);
+    this.kind = kind;
+    this.detail = detail;
+  }
+  toDisplayString() {
+    const label = this.kind === "InvalidInput" ? "Invalid input" : this.kind === "NotFound" ? "Not found" : null;
+    if (!label) {
+      return this.detail;
+    }
+    if (this.detail.includes("\n")) {
+      return `${label}:
+${this.detail}`;
+    }
+    return `${label}: ${this.detail}`;
+  }
+};
+function invalidInput(message) {
+  return new AppError("InvalidInput", message);
+}
+function notFound(message) {
+  return new AppError("NotFound", message);
+}
+
+// src/lib/util.ts
+function ensureNonEmpty(label, value) {
+  if (value.trim().length === 0) {
+    throw invalidInput(`${label} cannot be empty`);
+  }
+}
+function formatDateTimeUTC(timestamp) {
+  const date = new Date(timestamp);
+  const yyyy = date.getUTCFullYear();
+  const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(date.getUTCDate()).padStart(2, "0");
+  const hh = String(date.getUTCHours()).padStart(2, "0");
+  const min = String(date.getUTCMinutes()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd} ${hh}:${min}`;
+}
+function uniqueIds(ids) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const id of ids) {
+    if (!seen.has(id)) {
+      seen.add(id);
+      unique.push(id);
+    }
+  }
+  return unique;
+}
+function joinIds(ids) {
+  return ids.map((id) => String(id)).join(", ");
+}
+function normalizeCommentEntries(entries) {
+  const seen = /* @__PURE__ */ new Map();
+  const ordered = [];
+  for (const [id, comment] of entries) {
+    const idx = seen.get(id);
+    if (idx !== void 0) {
+      ordered[idx][1] = comment;
+    } else {
+      seen.set(id, ordered.length);
+      ordered.push([id, comment]);
+    }
+  }
+  return ordered;
+}
+var WAIT_UNTIL_PREFIX = "@wait-until=";
+var WAIT_REASON_PREFIX = "@wait-reason=";
+function parseWaitFromComment(comment) {
+  if (!comment) return null;
+  let until = null;
+  let reason;
+  for (const line of comment.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(WAIT_UNTIL_PREFIX)) {
+      const raw = trimmed.slice(WAIT_UNTIL_PREFIX.length).trim();
+      const value = Number(raw);
+      if (Number.isFinite(value)) {
+        until = value;
+      }
+      continue;
+    }
+    if (trimmed.startsWith(WAIT_REASON_PREFIX)) {
+      const raw = trimmed.slice(WAIT_REASON_PREFIX.length).trim();
+      if (raw) reason = raw;
+    }
+  }
+  if (until === null) return null;
+  return { until, reason };
+}
+function isWaitLine(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith(WAIT_UNTIL_PREFIX) || trimmed.startsWith(WAIT_REASON_PREFIX);
+}
+function upsertWaitInComment(comment, until, reason) {
+  const lines = comment ? comment.split(/\r?\n/) : [];
+  const filtered = lines.filter((line) => !isWaitLine(line));
+  const waitLines = [`${WAIT_UNTIL_PREFIX}${Math.trunc(until)}`];
+  const reasonValue = reason?.trim();
+  if (reasonValue) {
+    waitLines.push(`${WAIT_REASON_PREFIX}${reasonValue}`);
+  }
+  return [...waitLines, ...filtered].join("\n").trimEnd();
+}
+function removeWaitFromComment(comment) {
+  if (!comment) return null;
+  const lines = comment.split(/\r?\n/).filter((line) => !isWaitLine(line));
+  const cleaned = lines.join("\n").trimEnd();
+  return cleaned.length ? cleaned : null;
+}
+function resolveMaybeRealpath(value) {
+  try {
+    return fs2.realpathSync.native(value);
+  } catch {
+    return value;
+  }
+}
+function normalizePath(value) {
+  let resolved = resolveMaybeRealpath(value);
+  resolved = path2.resolve(resolved);
+  if (process.platform === "win32") {
+    resolved = resolved.toLowerCase();
+  }
+  return resolved.replace(/[\\/]+$/, "");
+}
+function projectMatchesPath(project, current) {
+  const projectNorm = normalizePath(project);
+  const currentNorm = normalizePath(current);
+  if (projectNorm === currentNorm) return true;
+  if (currentNorm.startsWith(projectNorm + path2.sep)) return true;
+  if (projectNorm.startsWith(currentNorm + path2.sep)) return true;
+  return false;
+}
+
+// src/lib/format.ts
+function hasText(value) {
+  return value !== void 0 && value !== null && value.trim().length > 0;
+}
+function formatStepDetail(step, goals) {
+  let output = "";
+  output += `Step ID: ${step.id}
+`;
+  output += `Plan ID: ${step.plan_id}
+`;
+  output += `Status: ${step.status}
+`;
+  output += `Executor: ${step.executor}
+`;
+  output += `Content: ${step.content}
+`;
+  if (hasText(step.comment)) {
+    output += `Comment: ${step.comment ?? ""}
+`;
+  }
+  output += `Created: ${formatDateTimeUTC(step.created_at)}
+`;
+  output += `Updated: ${formatDateTimeUTC(step.updated_at)}
+`;
+  output += "\n";
+  if (!goals.length) {
+    output += "Goals: (none)";
+    return output.trimEnd();
+  }
+  output += "Goals:\n";
+  for (const goal of goals) {
+    output += `- [${goal.status}] ${goal.content} (goal id ${goal.id})
+`;
+    if (hasText(goal.comment)) {
+      output += `  Comment: ${goal.comment ?? ""}
+`;
+    }
+  }
+  return output.trimEnd();
+}
+function formatGoalDetail(goal, step) {
+  let output = "";
+  output += `Goal ID: ${goal.id}
+`;
+  output += `Step ID: ${goal.step_id}
+`;
+  output += `Plan ID: ${step.plan_id}
+`;
+  output += `Status: ${goal.status}
+`;
+  output += `Content: ${goal.content}
+`;
+  if (hasText(goal.comment)) {
+    output += `Comment: ${goal.comment ?? ""}
+`;
+  }
+  output += `Created: ${formatDateTimeUTC(goal.created_at)}
+`;
+  output += `Updated: ${formatDateTimeUTC(goal.updated_at)}
+`;
+  output += "\n";
+  output += `Step Status: ${step.status}
+`;
+  output += `Step Executor: ${step.executor}
+`;
+  output += `Step Content: ${step.content}
+`;
+  if (hasText(step.comment)) {
+    output += `Step Comment: ${step.comment ?? ""}
+`;
+  }
+  return output.trimEnd();
+}
+function formatPlanDetail(plan, steps, goals) {
+  let output = "";
+  output += `Plan ID: ${plan.id}
+`;
+  output += `Title: ${plan.title}
+`;
+  output += `Status: ${plan.status}
+`;
+  output += `Content: ${plan.content}
+`;
+  if (hasText(plan.comment)) {
+    output += `Comment: ${plan.comment ?? ""}
+`;
+  }
+  output += `Created: ${formatDateTimeUTC(plan.created_at)}
+`;
+  output += `Updated: ${formatDateTimeUTC(plan.updated_at)}
+`;
+  output += "\n";
+  if (!steps.length) {
+    output += "Steps: (none)";
+    return output.trimEnd();
+  }
+  output += "Steps:\n";
+  for (const step of steps) {
+    const stepGoals = goals.get(step.id) ?? [];
+    if (stepGoals.length) {
+      const done = stepGoals.filter((goal) => goal.status === "done").length;
+      output += `- [${step.status}] ${step.content} (step id ${step.id}, exec ${step.executor}, goals ${done}/${stepGoals.length})
+`;
+    } else {
+      output += `- [${step.status}] ${step.content} (step id ${step.id}, exec ${step.executor})
+`;
+    }
+    if (hasText(step.comment)) {
+      output += `  Comment: ${step.comment ?? ""}
+`;
+    }
+    if (stepGoals.length) {
+      for (const goal of stepGoals) {
+        output += `  - [${goal.status}] ${goal.content} (goal id ${goal.id})
+`;
+        if (hasText(goal.comment)) {
+          output += `    Comment: ${goal.comment ?? ""}
+`;
+        }
+      }
+    }
+  }
+  return output.trimEnd();
+}
+function formatPlanMarkdown(active, activeUpdated, plan, steps, goals) {
+  const lines = [];
+  const checkbox = (status) => status === "done" ? "x" : " ";
+  const collapseHeading = (text) => {
+    const normalized = text.replace(/\r\n/g, "\n");
+    const parts = normalized.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    if (!parts.length) return "(untitled)";
+    return parts.join(" / ");
+  };
+  const splitTaskText = (text) => {
+    const normalized = text.replace(/\r\n/g, "\n");
+    const rawLines = normalized.split("\n");
+    if (!rawLines.length) return ["(empty)", []];
+    let firstIdx = -1;
+    for (let i = 0; i < rawLines.length; i += 1) {
+      if (rawLines[i].trim()) {
+        firstIdx = i;
+        break;
+      }
+    }
+    if (firstIdx === -1) return ["(empty)", []];
+    return [rawLines[firstIdx], rawLines.slice(firstIdx + 1)];
+  };
+  const pushLine = (indent, text) => {
+    lines.push(`${" ".repeat(indent)}${text}`);
+  };
+  const pushBlank = (indent) => {
+    lines.push(indent === 0 ? "" : " ".repeat(indent));
+  };
+  pushLine(0, "# Plan");
+  pushBlank(0);
+  pushLine(0, `## Plan: ${collapseHeading(plan.title)}`);
+  pushBlank(0);
+  pushLine(0, `- **Active:** \`${active ? "true" : "false"}\``);
+  pushLine(0, `- **Plan ID:** \`${plan.id}\``);
+  pushLine(0, `- **Status:** \`${plan.status}\``);
+  if (hasText(plan.comment)) {
+    pushLine(0, `- **Comment:** ${plan.comment ?? ""}`);
+  }
+  if (activeUpdated) {
+    pushLine(0, `- **Activated:** ${formatDateTimeUTC(activeUpdated)}`);
+  }
+  pushLine(0, `- **Created:** ${formatDateTimeUTC(plan.created_at)}`);
+  pushLine(0, `- **Updated:** ${formatDateTimeUTC(plan.updated_at)}`);
+  const stepsDone = steps.filter((step) => step.status === "done").length;
+  pushLine(0, `- **Steps:** ${stepsDone}/${steps.length}`);
+  pushBlank(0);
+  pushLine(0, "### Plan Content");
+  pushBlank(0);
+  if (!plan.content.trim()) {
+    pushLine(0, "*No content*");
+  } else {
+    const normalized = plan.content.replace(/\r\n/g, "\n");
+    for (const line of normalized.split("\n")) {
+      if (!line.length) {
+        pushLine(0, ">");
+      } else {
+        pushLine(0, `> ${line}`);
+      }
+    }
+  }
+  pushBlank(0);
+  pushLine(0, "### Steps");
+  pushBlank(0);
+  if (!steps.length) {
+    pushLine(0, "*No steps*");
+    return lines.join("\n").trimEnd();
+  }
+  steps.forEach((step, idx) => {
+    const [firstLine, restLines] = splitTaskText(step.content);
+    pushLine(0, `- [${checkbox(step.status)}] **${firstLine}** *(id: ${step.id}, exec: ${step.executor}, order: ${step.sort_order})*`);
+    let hasRest = false;
+    for (const line of restLines) {
+      if (!line.trim()) continue;
+      if (!hasRest) {
+        pushBlank(2);
+        hasRest = true;
+      } else {
+        pushBlank(2);
+      }
+      pushLine(2, line);
+    }
+    pushBlank(2);
+    pushLine(2, `- Created: ${formatDateTimeUTC(step.created_at)}`);
+    pushLine(2, `- Updated: ${formatDateTimeUTC(step.updated_at)}`);
+    if (hasText(step.comment)) {
+      pushLine(2, `- Comment: ${step.comment ?? ""}`);
+    }
+    const stepGoals = goals.get(step.id);
+    if (stepGoals && stepGoals.length) {
+      const done = stepGoals.filter((goal) => goal.status === "done").length;
+      pushLine(2, `- Goals: ${done}/${stepGoals.length}`);
+      for (const goal of stepGoals) {
+        const [goalFirst, goalRest] = splitTaskText(goal.content);
+        pushBlank(2);
+        pushLine(2, `- [${checkbox(goal.status)}] ${goalFirst} *(id: ${goal.id})*`);
+        for (const line of goalRest) {
+          if (!line.trim()) continue;
+          pushBlank(4);
+          pushLine(4, line);
+        }
+        if (hasText(goal.comment)) {
+          pushBlank(4);
+          pushLine(4, `Comment: ${goal.comment ?? ""}`);
+        }
+      }
+    } else {
+      pushLine(2, "- Goals: 0/0");
+      pushBlank(2);
+      pushLine(2, "- (none)");
+    }
+    if (idx + 1 < steps.length) {
+      pushBlank(0);
+    }
+  });
+  return lines.join("\n").trimEnd();
+}
+
+// src/lib/app.ts
+var PlanpilotApp = class {
+  db;
+  sessionId;
+  cwd;
+  constructor(db, sessionId, cwd) {
+    this.db = db;
+    this.sessionId = sessionId;
+    this.cwd = cwd;
+  }
+  addPlan(input) {
+    ensureNonEmpty("plan title", input.title);
+    ensureNonEmpty("plan content", input.content);
+    const now = Date.now();
+    const result = this.db.prepare(
+      `INSERT INTO plans (title, content, status, comment, last_session_id, last_cwd, created_at, updated_at)
+         VALUES (?, ?, ?, NULL, ?, ?, ?, ?)`
+    ).run(input.title, input.content, "todo", this.sessionId, this.cwd ?? null, now, now);
+    const plan = this.getPlan(result.lastInsertRowid);
+    return plan;
+  }
+  addPlanTree(input, steps) {
+    ensureNonEmpty("plan title", input.title);
+    ensureNonEmpty("plan content", input.content);
+    steps.forEach((step) => {
+      ensureNonEmpty("step content", step.content);
+      step.goals.forEach((goal) => ensureNonEmpty("goal content", goal));
+    });
+    const tx = this.db.transaction(() => {
+      const now = Date.now();
+      const planResult = this.db.prepare(
+        `INSERT INTO plans (title, content, status, comment, last_session_id, last_cwd, created_at, updated_at)
+           VALUES (?, ?, ?, NULL, ?, ?, ?, ?)`
+      ).run(input.title, input.content, "todo", this.sessionId, this.cwd ?? null, now, now);
+      const plan = this.getPlan(planResult.lastInsertRowid);
+      let stepCount = 0;
+      let goalCount = 0;
+      steps.forEach((step, idx) => {
+        const stepResult = this.db.prepare(
+          `INSERT INTO steps (plan_id, content, status, executor, sort_order, comment, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, NULL, ?, ?)`
+        ).run(plan.id, step.content, "todo", step.executor, idx + 1, now, now);
+        const stepId = stepResult.lastInsertRowid;
+        stepCount += 1;
+        step.goals.forEach((goal) => {
+          this.db.prepare(
+            `INSERT INTO goals (step_id, content, status, comment, created_at, updated_at)
+               VALUES (?, ?, ?, NULL, ?, ?)`
+          ).run(stepId, goal, "todo", now, now);
+          goalCount += 1;
+        });
+      });
+      return { plan, stepCount, goalCount };
+    });
+    return tx();
+  }
+  listPlans(order, desc) {
+    const orderBy = order ?? "updated";
+    const direction = desc ? "DESC" : "ASC";
+    const orderColumn = orderBy === "id" ? "id" : orderBy === "title" ? "title" : orderBy === "created" ? "created_at" : "updated_at";
+    return this.db.prepare(`SELECT * FROM plans ORDER BY ${orderColumn} ${direction}, id ASC`).all();
+  }
+  getPlan(id) {
+    const row = this.db.prepare("SELECT * FROM plans WHERE id = ?").get(id);
+    if (!row) throw notFound(`plan id ${id}`);
+    return row;
+  }
+  getStep(id) {
+    const row = this.db.prepare("SELECT * FROM steps WHERE id = ?").get(id);
+    if (!row) throw notFound(`step id ${id}`);
+    return row;
+  }
+  getGoal(id) {
+    const row = this.db.prepare("SELECT * FROM goals WHERE id = ?").get(id);
+    if (!row) throw notFound(`goal id ${id}`);
+    return row;
+  }
+  planWithSteps(id) {
+    const plan = this.getPlan(id);
+    const steps = this.db.prepare("SELECT * FROM steps WHERE plan_id = ? ORDER BY sort_order ASC, id ASC").all(id);
+    return { plan, steps };
+  }
+  getPlanDetail(id) {
+    const plan = this.getPlan(id);
+    const steps = this.db.prepare("SELECT * FROM steps WHERE plan_id = ? ORDER BY sort_order ASC, id ASC").all(id);
+    const stepIds = steps.map((step) => step.id);
+    const goals = this.goalsForSteps(stepIds);
+    const goalsMap = /* @__PURE__ */ new Map();
+    for (const step of steps) {
+      goalsMap.set(step.id, goals.get(step.id) ?? []);
+    }
+    return { plan, steps, goals: goalsMap };
+  }
+  getStepDetail(id) {
+    const step = this.getStep(id);
+    const goals = this.goalsForStep(step.id);
+    return { step, goals };
+  }
+  getGoalDetail(id) {
+    const goal = this.getGoal(id);
+    const step = this.getStep(goal.step_id);
+    return { goal, step };
+  }
+  getPlanDetails(plans) {
+    if (!plans.length) return [];
+    const planIds = plans.map((plan) => plan.id);
+    const steps = this.db.prepare(`SELECT * FROM steps WHERE plan_id IN (${planIds.map(() => "?").join(",")}) ORDER BY plan_id ASC, sort_order ASC, id ASC`).all(...planIds);
+    const stepIds = steps.map((step) => step.id);
+    const goalsByStep = this.goalsForSteps(stepIds);
+    const stepsByPlan = /* @__PURE__ */ new Map();
+    for (const step of steps) {
+      const list = stepsByPlan.get(step.plan_id);
+      if (list) list.push(step);
+      else stepsByPlan.set(step.plan_id, [step]);
+    }
+    return plans.map((plan) => {
+      const planSteps = stepsByPlan.get(plan.id) ?? [];
+      const goalsMap = /* @__PURE__ */ new Map();
+      for (const step of planSteps) {
+        goalsMap.set(step.id, goalsByStep.get(step.id) ?? []);
+      }
+      return { plan, steps: planSteps, goals: goalsMap };
+    });
+  }
+  getStepsDetail(steps) {
+    if (!steps.length) return [];
+    const stepIds = steps.map((step) => step.id);
+    const goalsMap = this.goalsForSteps(stepIds);
+    return steps.map((step) => ({
+      step,
+      goals: goalsMap.get(step.id) ?? []
+    }));
+  }
+  getActivePlan() {
+    const row = this.db.prepare("SELECT * FROM active_plan WHERE session_id = ?").get(this.sessionId);
+    return row ?? null;
+  }
+  setActivePlan(planId, takeover) {
+    this.getPlan(planId);
+    const tx = this.db.transaction(() => {
+      const existing = this.db.prepare("SELECT * FROM active_plan WHERE plan_id = ?").get(planId);
+      if (existing && existing.session_id !== this.sessionId && !takeover) {
+        throw invalidInput(
+          `plan id ${planId} is already active in session ${existing.session_id} (use --force to take over)`
+        );
+      }
+      this.db.prepare("DELETE FROM active_plan WHERE session_id = ?").run(this.sessionId);
+      this.db.prepare("DELETE FROM active_plan WHERE plan_id = ?").run(planId);
+      const now = Date.now();
+      this.db.prepare("INSERT INTO active_plan (session_id, plan_id, updated_at) VALUES (?, ?, ?)").run(this.sessionId, planId, now);
+      this.touchPlan(planId);
+      const created = this.db.prepare("SELECT * FROM active_plan WHERE session_id = ?").get(this.sessionId);
+      if (!created) throw notFound("active plan not found after insert");
+      return created;
+    });
+    return tx();
+  }
+  clearActivePlan() {
+    this.db.prepare("DELETE FROM active_plan WHERE session_id = ?").run(this.sessionId);
+  }
+  updatePlanWithActiveClear(id, changes) {
+    const tx = this.db.transaction(() => {
+      const plan = this.updatePlanWithConn(id, changes);
+      let cleared = false;
+      if (plan.status === "done") {
+        cleared = this.clearActivePlansForPlanWithConn(plan.id);
+      }
+      return { plan, cleared };
+    });
+    return tx();
+  }
+  deletePlan(id) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM active_plan WHERE plan_id = ?").run(id);
+      const stepIds = this.db.prepare("SELECT id FROM steps WHERE plan_id = ?").all(id).map((row) => row.id);
+      if (stepIds.length) {
+        this.db.prepare(`DELETE FROM goals WHERE step_id IN (${stepIds.map(() => "?").join(",")})`).run(...stepIds);
+        this.db.prepare("DELETE FROM steps WHERE plan_id = ?").run(id);
+      }
+      const result = this.db.prepare("DELETE FROM plans WHERE id = ?").run(id);
+      if (result.changes === 0) {
+        throw notFound(`plan id ${id}`);
+      }
+    });
+    tx();
+  }
+  addStepsBatch(planId, contents, status, executor, at) {
+    if (!this.db.prepare("SELECT 1 FROM plans WHERE id = ?").get(planId)) {
+      throw notFound(`plan id ${planId}`);
+    }
+    if (!contents.length) {
+      return { steps: [], changes: createEmptyStatusChanges() };
+    }
+    contents.forEach((content) => ensureNonEmpty("step content", content));
+    const tx = this.db.transaction(() => {
+      const existing = this.db.prepare("SELECT * FROM steps WHERE plan_id = ? ORDER BY sort_order ASC, id ASC").all(planId);
+      this.normalizeStepsInPlace(existing);
+      const total = existing.length;
+      const insertPos = at !== void 0 && at !== null ? at > 0 ? Math.min(at, total + 1) : 1 : total + 1;
+      const now = Date.now();
+      const shiftBy = contents.length;
+      if (shiftBy > 0) {
+        for (let idx = existing.length - 1; idx >= 0; idx -= 1) {
+          const step = existing[idx];
+          if (step.sort_order >= insertPos) {
+            const newOrder = step.sort_order + shiftBy;
+            this.db.prepare("UPDATE steps SET sort_order = ?, updated_at = ? WHERE id = ?").run(newOrder, now, step.id);
+            step.sort_order = newOrder;
+            step.updated_at = now;
+          }
+        }
+      }
+      const created = [];
+      contents.forEach((content, idx) => {
+        const sortOrder = insertPos + idx;
+        const result = this.db.prepare(
+          `INSERT INTO steps (plan_id, content, status, executor, sort_order, comment, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, NULL, ?, ?)`
+        ).run(planId, content, status, executor, sortOrder, now, now);
+        const step = this.getStep(result.lastInsertRowid);
+        created.push(step);
+      });
+      const changes = this.refreshPlanStatus(planId);
+      this.touchPlan(planId);
+      return { steps: created, changes };
+    });
+    return tx();
+  }
+  addStepTree(planId, content, executor, goals) {
+    ensureNonEmpty("step content", content);
+    goals.forEach((goal) => ensureNonEmpty("goal content", goal));
+    const tx = this.db.transaction(() => {
+      if (!this.db.prepare("SELECT 1 FROM plans WHERE id = ?").get(planId)) {
+        throw notFound(`plan id ${planId}`);
+      }
+      const existing = this.db.prepare("SELECT * FROM steps WHERE plan_id = ? ORDER BY sort_order ASC, id ASC").all(planId);
+      this.normalizeStepsInPlace(existing);
+      const sortOrder = existing.length + 1;
+      const now = Date.now();
+      const stepResult = this.db.prepare(
+        `INSERT INTO steps (plan_id, content, status, executor, sort_order, comment, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, NULL, ?, ?)`
+      ).run(planId, content, "todo", executor, sortOrder, now, now);
+      const step = this.getStep(stepResult.lastInsertRowid);
+      const createdGoals = [];
+      for (const goalContent of goals) {
+        const goalResult = this.db.prepare(
+          `INSERT INTO goals (step_id, content, status, comment, created_at, updated_at)
+             VALUES (?, ?, ?, NULL, ?, ?)`
+        ).run(step.id, goalContent, "todo", now, now);
+        createdGoals.push(this.getGoal(goalResult.lastInsertRowid));
+      }
+      const changes = this.refreshPlanStatus(planId);
+      this.touchPlan(planId);
+      return { step, goals: createdGoals, changes };
+    });
+    return tx();
+  }
+  listStepsFiltered(planId, query) {
+    this.getPlan(planId);
+    const conditions = ["plan_id = ?"];
+    const params = [planId];
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query.executor) {
+      conditions.push("executor = ?");
+      params.push(query.executor);
+    }
+    const order = query.order ?? "order";
+    const direction = query.desc ? "DESC" : "ASC";
+    const orderColumn = order === "id" ? "id" : order === "created" ? "created_at" : order === "updated" ? "updated_at" : "sort_order";
+    let sql = `SELECT * FROM steps WHERE ${conditions.join(" AND ")} ORDER BY ${orderColumn} ${direction}, id ASC`;
+    if (query.limit !== void 0) {
+      sql += " LIMIT ?";
+      params.push(query.limit);
+    }
+    if (query.offset !== void 0) {
+      sql += " OFFSET ?";
+      params.push(query.offset);
+    }
+    return this.db.prepare(sql).all(...params);
+  }
+  countSteps(planId, query) {
+    this.getPlan(planId);
+    const conditions = ["plan_id = ?"];
+    const params = [planId];
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query.executor) {
+      conditions.push("executor = ?");
+      params.push(query.executor);
+    }
+    const row = this.db.prepare(`SELECT COUNT(*) as count FROM steps WHERE ${conditions.join(" AND ")}`).get(...params);
+    return row.count;
+  }
+  nextStep(planId) {
+    const row = this.db.prepare("SELECT * FROM steps WHERE plan_id = ? AND status = ? ORDER BY sort_order ASC, id ASC LIMIT 1").get(planId, "todo");
+    return row ?? null;
+  }
+  updateStep(id, changes) {
+    const tx = this.db.transaction(() => {
+      if (changes.content !== void 0) {
+        ensureNonEmpty("step content", changes.content);
+      }
+      if (changes.status === "done") {
+        const pending = this.nextGoalForStep(id);
+        if (pending) {
+          throw invalidInput(`cannot mark step done; next pending goal: ${pending.content} (id ${pending.id})`);
+        }
+      }
+      const existing = this.getStep(id);
+      const now = Date.now();
+      const updated = {
+        content: changes.content ?? existing.content,
+        status: changes.status ?? existing.status,
+        executor: changes.executor ?? existing.executor,
+        comment: changes.comment !== void 0 ? changes.comment : existing.comment
+      };
+      this.db.prepare(
+        `UPDATE steps SET content = ?, status = ?, executor = ?, comment = ?, updated_at = ? WHERE id = ?`
+      ).run(updated.content, updated.status, updated.executor, updated.comment, now, id);
+      const step = this.getStep(id);
+      const statusChanges = createEmptyStatusChanges();
+      if (changes.status !== void 0) {
+        mergeStatusChanges(statusChanges, this.refreshPlanStatus(step.plan_id));
+      }
+      this.touchPlan(step.plan_id);
+      return { step, changes: statusChanges };
+    });
+    return tx();
+  }
+  setStepDoneWithGoals(id, allGoals) {
+    const tx = this.db.transaction(() => {
+      let changes = createEmptyStatusChanges();
+      if (allGoals) {
+        const goalChanges = this.setAllGoalsDoneForStep(id);
+        mergeStatusChanges(changes, goalChanges);
+      } else {
+        const pending = this.nextGoalForStep(id);
+        if (pending) {
+          throw invalidInput(`cannot mark step done; next pending goal: ${pending.content} (id ${pending.id})`);
+        }
+      }
+      const existing = this.getStep(id);
+      if (existing.status !== "done") {
+        const now = Date.now();
+        this.db.prepare("UPDATE steps SET status = ?, updated_at = ? WHERE id = ?").run("done", now, id);
+      }
+      const step = this.getStep(id);
+      mergeStatusChanges(changes, this.refreshPlanStatus(step.plan_id));
+      this.touchPlan(step.plan_id);
+      return { step, changes };
+    });
+    return tx();
+  }
+  moveStep(id, to) {
+    const tx = this.db.transaction(() => {
+      const target = this.getStep(id);
+      const planId = target.plan_id;
+      const steps = this.db.prepare("SELECT * FROM steps WHERE plan_id = ? ORDER BY sort_order ASC, id ASC").all(planId);
+      const currentIndex = steps.findIndex((step) => step.id === id);
+      if (currentIndex === -1) throw notFound(`step id ${id}`);
+      let desiredIndex = Math.max(to - 1, 0);
+      if (desiredIndex >= steps.length) desiredIndex = steps.length - 1;
+      const [moving] = steps.splice(currentIndex, 1);
+      if (desiredIndex >= steps.length) steps.push(moving);
+      else steps.splice(desiredIndex, 0, moving);
+      const now = Date.now();
+      steps.forEach((step, idx) => {
+        const desiredOrder = idx + 1;
+        if (step.sort_order !== desiredOrder) {
+          this.db.prepare("UPDATE steps SET sort_order = ?, updated_at = ? WHERE id = ?").run(desiredOrder, now, step.id);
+          step.sort_order = desiredOrder;
+          step.updated_at = now;
+        }
+      });
+      return steps;
+    });
+    return tx();
+  }
+  deleteSteps(ids) {
+    const tx = this.db.transaction(() => {
+      if (!ids.length) return { deleted: 0, changes: createEmptyStatusChanges() };
+      const unique = uniqueIds(ids);
+      const steps = this.db.prepare(`SELECT * FROM steps WHERE id IN (${unique.map(() => "?").join(",")})`).all(...unique);
+      const existing = new Set(steps.map((step) => step.id));
+      const missing = unique.filter((id) => !existing.has(id));
+      if (missing.length) {
+        throw notFound(`step id(s) not found: ${joinIds(missing)}`);
+      }
+      const planIds = Array.from(new Set(steps.map((step) => step.plan_id)));
+      if (unique.length) {
+        this.db.prepare(`DELETE FROM goals WHERE step_id IN (${unique.map(() => "?").join(",")})`).run(...unique);
+      }
+      const result = this.db.prepare(`DELETE FROM steps WHERE id IN (${unique.map(() => "?").join(",")})`).run(...unique);
+      planIds.forEach((planId) => this.normalizeStepsForPlan(planId));
+      const changes = createEmptyStatusChanges();
+      planIds.forEach((planId) => mergeStatusChanges(changes, this.refreshPlanStatus(planId)));
+      if (planIds.length) {
+        this.touchPlans(planIds);
+      }
+      return { deleted: result.changes, changes };
+    });
+    return tx();
+  }
+  addGoalsBatch(stepId, contents, status) {
+    if (!contents.length) return { goals: [], changes: createEmptyStatusChanges() };
+    contents.forEach((content) => ensureNonEmpty("goal content", content));
+    const tx = this.db.transaction(() => {
+      const step = this.getStep(stepId);
+      const now = Date.now();
+      const created = [];
+      contents.forEach((content) => {
+        const result = this.db.prepare(
+          `INSERT INTO goals (step_id, content, status, comment, created_at, updated_at)
+             VALUES (?, ?, ?, NULL, ?, ?)`
+        ).run(stepId, content, status, now, now);
+        created.push(this.getGoal(result.lastInsertRowid));
+      });
+      const changes = this.refreshStepStatus(stepId);
+      this.touchPlan(step.plan_id);
+      return { goals: created, changes };
+    });
+    return tx();
+  }
+  listGoalsFiltered(stepId, query) {
+    this.getStep(stepId);
+    const conditions = ["step_id = ?"];
+    const params = [stepId];
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    let sql = `SELECT * FROM goals WHERE ${conditions.join(" AND ")} ORDER BY updated_at DESC, id DESC`;
+    if (query.limit !== void 0) {
+      sql += " LIMIT ?";
+      params.push(query.limit);
+    }
+    if (query.offset !== void 0) {
+      sql += " OFFSET ?";
+      params.push(query.offset);
+    }
+    return this.db.prepare(sql).all(...params);
+  }
+  countGoals(stepId, query) {
+    this.getStep(stepId);
+    const conditions = ["step_id = ?"];
+    const params = [stepId];
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    const row = this.db.prepare(`SELECT COUNT(*) as count FROM goals WHERE ${conditions.join(" AND ")}`).get(...params);
+    return row.count;
+  }
+  updateGoal(id, changes) {
+    const tx = this.db.transaction(() => {
+      if (changes.content !== void 0) {
+        ensureNonEmpty("goal content", changes.content);
+      }
+      const existing = this.getGoal(id);
+      const now = Date.now();
+      const updated = {
+        content: changes.content ?? existing.content,
+        status: changes.status ?? existing.status,
+        comment: changes.comment !== void 0 ? changes.comment : existing.comment
+      };
+      this.db.prepare("UPDATE goals SET content = ?, status = ?, comment = ?, updated_at = ? WHERE id = ?").run(updated.content, updated.status, updated.comment, now, id);
+      const goal = this.getGoal(id);
+      const statusChanges = createEmptyStatusChanges();
+      if (changes.status !== void 0) {
+        mergeStatusChanges(statusChanges, this.refreshStepStatus(goal.step_id));
+      }
+      const step = this.getStep(goal.step_id);
+      this.touchPlan(step.plan_id);
+      return { goal, changes: statusChanges };
+    });
+    return tx();
+  }
+  setGoalStatus(id, status) {
+    const tx = this.db.transaction(() => {
+      this.getGoal(id);
+      const now = Date.now();
+      this.db.prepare("UPDATE goals SET status = ?, updated_at = ? WHERE id = ?").run(status, now, id);
+      const goal = this.getGoal(id);
+      const changes = this.refreshStepStatus(goal.step_id);
+      const step = this.getStep(goal.step_id);
+      this.touchPlan(step.plan_id);
+      return { goal, changes };
+    });
+    return tx();
+  }
+  setGoalsStatus(ids, status) {
+    if (!ids.length) return { updated: 0, changes: createEmptyStatusChanges() };
+    const tx = this.db.transaction(() => {
+      const unique = uniqueIds(ids);
+      const goals = this.db.prepare(`SELECT * FROM goals WHERE id IN (${unique.map(() => "?").join(",")})`).all(...unique);
+      const existing = new Set(goals.map((goal) => goal.id));
+      const missing = unique.filter((id) => !existing.has(id));
+      if (missing.length) {
+        throw notFound(`goal id(s) not found: ${joinIds(missing)}`);
+      }
+      const now = Date.now();
+      const stepIds = [];
+      const stepSeen = /* @__PURE__ */ new Set();
+      goals.forEach((goal) => {
+        if (!stepSeen.has(goal.step_id)) {
+          stepSeen.add(goal.step_id);
+          stepIds.push(goal.step_id);
+        }
+        this.db.prepare("UPDATE goals SET status = ?, updated_at = ? WHERE id = ?").run(status, now, goal.id);
+      });
+      const changes = createEmptyStatusChanges();
+      stepIds.forEach((stepId) => mergeStatusChanges(changes, this.refreshStepStatus(stepId)));
+      const planIds = [];
+      if (stepIds.length) {
+        const steps = this.db.prepare(`SELECT plan_id FROM steps WHERE id IN (${stepIds.map(() => "?").join(",")})`).all(...stepIds);
+        const seen = /* @__PURE__ */ new Set();
+        steps.forEach((row) => {
+          if (!seen.has(row.plan_id)) {
+            seen.add(row.plan_id);
+            planIds.push(row.plan_id);
+          }
+        });
+      }
+      if (planIds.length) this.touchPlans(planIds);
+      return { updated: unique.length, changes };
+    });
+    return tx();
+  }
+  deleteGoals(ids) {
+    const tx = this.db.transaction(() => {
+      if (!ids.length) return { deleted: 0, changes: createEmptyStatusChanges() };
+      const unique = uniqueIds(ids);
+      const goals = this.db.prepare(`SELECT * FROM goals WHERE id IN (${unique.map(() => "?").join(",")})`).all(...unique);
+      const existing = new Set(goals.map((goal) => goal.id));
+      const missing = unique.filter((id) => !existing.has(id));
+      if (missing.length) {
+        throw notFound(`goal id(s) not found: ${joinIds(missing)}`);
+      }
+      const stepIds = Array.from(new Set(goals.map((goal) => goal.step_id)));
+      const result = this.db.prepare(`DELETE FROM goals WHERE id IN (${unique.map(() => "?").join(",")})`).run(...unique);
+      const changes = createEmptyStatusChanges();
+      stepIds.forEach((stepId) => mergeStatusChanges(changes, this.refreshStepStatus(stepId)));
+      if (stepIds.length) {
+        const planIds = [];
+        const steps = this.db.prepare(`SELECT plan_id FROM steps WHERE id IN (${stepIds.map(() => "?").join(",")})`).all(...stepIds);
+        const seen = /* @__PURE__ */ new Set();
+        steps.forEach((row) => {
+          if (!seen.has(row.plan_id)) {
+            seen.add(row.plan_id);
+            planIds.push(row.plan_id);
+          }
+        });
+        if (planIds.length) this.touchPlans(planIds);
+      }
+      return { deleted: result.changes, changes };
+    });
+    return tx();
+  }
+  commentPlans(entries) {
+    const normalized = normalizeCommentEntries(entries);
+    if (!normalized.length) return [];
+    const ids = normalized.map(([id]) => id);
+    const tx = this.db.transaction(() => {
+      const existing = this.db.prepare(`SELECT id FROM plans WHERE id IN (${ids.map(() => "?").join(",")})`).all(...ids).map((row) => row.id);
+      const existingSet = new Set(existing);
+      const missing = ids.filter((id) => !existingSet.has(id));
+      if (missing.length) {
+        throw notFound(`plan id(s) not found: ${joinIds(missing)}`);
+      }
+      const now = Date.now();
+      normalized.forEach(([planId, comment]) => {
+        if (this.cwd) {
+          this.db.prepare("UPDATE plans SET comment = ?, last_session_id = ?, last_cwd = ?, updated_at = ? WHERE id = ?").run(comment, this.sessionId, this.cwd, now, planId);
+        } else {
+          this.db.prepare("UPDATE plans SET comment = ?, last_session_id = ?, updated_at = ? WHERE id = ?").run(comment, this.sessionId, now, planId);
+        }
+      });
+      return ids;
+    });
+    return tx();
+  }
+  commentSteps(entries) {
+    const normalized = normalizeCommentEntries(entries);
+    if (!normalized.length) return [];
+    const ids = normalized.map(([id]) => id);
+    const tx = this.db.transaction(() => {
+      const steps = this.db.prepare(`SELECT * FROM steps WHERE id IN (${ids.map(() => "?").join(",")})`).all(...ids);
+      const existing = new Set(steps.map((step) => step.id));
+      const missing = ids.filter((id) => !existing.has(id));
+      if (missing.length) {
+        throw notFound(`step id(s) not found: ${joinIds(missing)}`);
+      }
+      const planIds = Array.from(new Set(steps.map((step) => step.plan_id)));
+      const now = Date.now();
+      normalized.forEach(([stepId, comment]) => {
+        this.db.prepare("UPDATE steps SET comment = ?, updated_at = ? WHERE id = ?").run(comment, now, stepId);
+      });
+      if (planIds.length) this.touchPlans(planIds);
+      return planIds;
+    });
+    return tx();
+  }
+  setStepWait(stepId, delayMs, reason) {
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+      throw invalidInput("delay must be a non-negative number");
+    }
+    const tx = this.db.transaction(() => {
+      const step = this.getStep(stepId);
+      const now = Date.now();
+      const until = now + Math.trunc(delayMs);
+      const comment = upsertWaitInComment(step.comment, until, reason);
+      this.db.prepare("UPDATE steps SET comment = ?, updated_at = ? WHERE id = ?").run(comment, now, stepId);
+      const updated = this.getStep(stepId);
+      this.touchPlan(updated.plan_id);
+      return { step: updated, until };
+    });
+    return tx();
+  }
+  clearStepWait(stepId) {
+    const tx = this.db.transaction(() => {
+      const step = this.getStep(stepId);
+      const comment = step.comment ? removeWaitFromComment(step.comment) : null;
+      const now = Date.now();
+      this.db.prepare("UPDATE steps SET comment = ?, updated_at = ? WHERE id = ?").run(comment, now, stepId);
+      const updated = this.getStep(stepId);
+      this.touchPlan(updated.plan_id);
+      return { step: updated };
+    });
+    return tx();
+  }
+  getStepWait(stepId) {
+    const step = this.getStep(stepId);
+    const wait = parseWaitFromComment(step.comment);
+    return { step, wait };
+  }
+  commentGoals(entries) {
+    const normalized = normalizeCommentEntries(entries);
+    if (!normalized.length) return [];
+    const ids = normalized.map(([id]) => id);
+    const tx = this.db.transaction(() => {
+      const goals = this.db.prepare(`SELECT * FROM goals WHERE id IN (${ids.map(() => "?").join(",")})`).all(...ids);
+      const existing = new Set(goals.map((goal) => goal.id));
+      const missing = ids.filter((id) => !existing.has(id));
+      if (missing.length) {
+        throw notFound(`goal id(s) not found: ${joinIds(missing)}`);
+      }
+      const stepIds = Array.from(new Set(goals.map((goal) => goal.step_id)));
+      const now = Date.now();
+      normalized.forEach(([goalId, comment]) => {
+        this.db.prepare("UPDATE goals SET comment = ?, updated_at = ? WHERE id = ?").run(comment, now, goalId);
+      });
+      if (stepIds.length) {
+        const planIds = [];
+        const steps = this.db.prepare(`SELECT plan_id FROM steps WHERE id IN (${stepIds.map(() => "?").join(",")})`).all(...stepIds);
+        const seen = /* @__PURE__ */ new Set();
+        steps.forEach((row) => {
+          if (!seen.has(row.plan_id)) {
+            seen.add(row.plan_id);
+            planIds.push(row.plan_id);
+          }
+        });
+        if (planIds.length) this.touchPlans(planIds);
+        return planIds;
+      }
+      return [];
+    });
+    return tx();
+  }
+  goalsForStep(stepId) {
+    return this.db.prepare("SELECT * FROM goals WHERE step_id = ? ORDER BY id ASC").all(stepId);
+  }
+  goalsForSteps(stepIds) {
+    const grouped = /* @__PURE__ */ new Map();
+    if (!stepIds.length) return grouped;
+    const rows = this.db.prepare(`SELECT * FROM goals WHERE step_id IN (${stepIds.map(() => "?").join(",")}) ORDER BY step_id ASC, id ASC`).all(...stepIds);
+    rows.forEach((goal) => {
+      const list = grouped.get(goal.step_id);
+      if (list) list.push(goal);
+      else grouped.set(goal.step_id, [goal]);
+    });
+    return grouped;
+  }
+  planIdsForSteps(ids) {
+    if (!ids.length) return [];
+    const unique = uniqueIds(ids);
+    const rows = this.db.prepare(`SELECT plan_id FROM steps WHERE id IN (${unique.map(() => "?").join(",")})`).all(...unique);
+    const seen = /* @__PURE__ */ new Set();
+    const planIds = [];
+    rows.forEach((row) => {
+      if (!seen.has(row.plan_id)) {
+        seen.add(row.plan_id);
+        planIds.push(row.plan_id);
+      }
+    });
+    return planIds;
+  }
+  planIdsForGoals(ids) {
+    if (!ids.length) return [];
+    const unique = uniqueIds(ids);
+    const goals = this.db.prepare(`SELECT step_id FROM goals WHERE id IN (${unique.map(() => "?").join(",")})`).all(...unique);
+    const stepIds = Array.from(new Set(goals.map((row) => row.step_id)));
+    if (!stepIds.length) return [];
+    const steps = this.db.prepare(`SELECT plan_id FROM steps WHERE id IN (${stepIds.map(() => "?").join(",")})`).all(...stepIds);
+    const seen = /* @__PURE__ */ new Set();
+    const planIds = [];
+    steps.forEach((row) => {
+      if (!seen.has(row.plan_id)) {
+        seen.add(row.plan_id);
+        planIds.push(row.plan_id);
+      }
+    });
+    return planIds;
+  }
+  updatePlanWithConn(id, changes) {
+    if (changes.title !== void 0) ensureNonEmpty("plan title", changes.title);
+    if (changes.content !== void 0) ensureNonEmpty("plan content", changes.content);
+    if (changes.status === "done") {
+      const total = this.db.prepare("SELECT COUNT(*) as count FROM steps WHERE plan_id = ?").get(id);
+      if (total.count > 0) {
+        const next = this.nextStep(id);
+        if (next) {
+          const goals = this.goalsForStep(next.id);
+          const detail = formatStepDetail(next, goals);
+          throw invalidInput(`cannot mark plan done; next pending step:
+${detail}`);
+        }
+      }
+    }
+    const existing = this.getPlan(id);
+    const now = Date.now();
+    const updated = {
+      title: changes.title ?? existing.title,
+      content: changes.content ?? existing.content,
+      status: changes.status ?? existing.status,
+      comment: changes.comment !== void 0 ? changes.comment : existing.comment
+    };
+    if (this.cwd) {
+      this.db.prepare(
+        `UPDATE plans SET title = ?, content = ?, status = ?, comment = ?, last_session_id = ?, last_cwd = ?, updated_at = ? WHERE id = ?`
+      ).run(updated.title, updated.content, updated.status, updated.comment, this.sessionId, this.cwd, now, id);
+    } else {
+      this.db.prepare(
+        `UPDATE plans SET title = ?, content = ?, status = ?, comment = ?, last_session_id = ?, updated_at = ? WHERE id = ?`
+      ).run(updated.title, updated.content, updated.status, updated.comment, this.sessionId, now, id);
+    }
+    return this.getPlan(id);
+  }
+  refreshPlanStatus(planId) {
+    const total = this.db.prepare("SELECT COUNT(*) as count FROM steps WHERE plan_id = ?").get(planId);
+    if (total.count === 0) return createEmptyStatusChanges();
+    const done = this.db.prepare("SELECT COUNT(*) as count FROM steps WHERE plan_id = ? AND status = ?").get(planId, "done");
+    const status = done.count === total.count ? "done" : "todo";
+    const plan = this.getPlan(planId);
+    const changes = createEmptyStatusChanges();
+    if (plan.status !== status) {
+      const now = Date.now();
+      const reason = done.count === total.count ? `all steps are done (${done.count}/${total.count})` : `steps done ${done.count}/${total.count}`;
+      this.db.prepare("UPDATE plans SET status = ?, updated_at = ? WHERE id = ?").run(status, now, planId);
+      changes.plans.push({ plan_id: planId, from: plan.status, to: status, reason });
+      if (status === "done") {
+        const clearedCurrent = this.clearActivePlansForPlanWithConn(planId);
+        if (clearedCurrent) {
+          changes.active_plans_cleared.push({ plan_id: planId, reason: "plan marked done" });
+        }
+      }
+    }
+    return changes;
+  }
+  refreshStepStatus(stepId) {
+    const goals = this.db.prepare("SELECT * FROM goals WHERE step_id = ? ORDER BY id ASC").all(stepId);
+    if (!goals.length) return createEmptyStatusChanges();
+    const doneCount = goals.filter((goal) => goal.status === "done").length;
+    const total = goals.length;
+    const status = doneCount === total ? "done" : "todo";
+    const step = this.getStep(stepId);
+    const changes = createEmptyStatusChanges();
+    if (step.status !== status) {
+      const now = Date.now();
+      const reason = doneCount === total ? `all goals are done (${doneCount}/${total})` : `goals done ${doneCount}/${total}`;
+      this.db.prepare("UPDATE steps SET status = ?, updated_at = ? WHERE id = ?").run(status, now, stepId);
+      changes.steps.push({ step_id: stepId, from: step.status, to: status, reason });
+    }
+    mergeStatusChanges(changes, this.refreshPlanStatus(step.plan_id));
+    return changes;
+  }
+  nextGoalForStep(stepId) {
+    const row = this.db.prepare("SELECT * FROM goals WHERE step_id = ? AND status = ? ORDER BY id ASC LIMIT 1").get(stepId, "todo");
+    return row ?? null;
+  }
+  setAllGoalsDoneForStep(stepId) {
+    this.getStep(stepId);
+    const goals = this.goalsForStep(stepId);
+    if (!goals.length) return createEmptyStatusChanges();
+    const ids = goals.map((goal) => goal.id);
+    return this.setGoalsStatus(ids, "done").changes;
+  }
+  touchPlan(planId) {
+    const now = Date.now();
+    if (this.cwd) {
+      const result = this.db.prepare("UPDATE plans SET last_session_id = ?, last_cwd = ?, updated_at = ? WHERE id = ?").run(this.sessionId, this.cwd, now, planId);
+      if (result.changes === 0) {
+        throw notFound(`plan id ${planId}`);
+      }
+    } else {
+      const result = this.db.prepare("UPDATE plans SET last_session_id = ?, updated_at = ? WHERE id = ?").run(this.sessionId, now, planId);
+      if (result.changes === 0) {
+        throw notFound(`plan id ${planId}`);
+      }
+    }
+  }
+  touchPlans(planIds) {
+    planIds.forEach((planId) => this.touchPlan(planId));
+  }
+  normalizeStepsForPlan(planId) {
+    const steps = this.db.prepare("SELECT * FROM steps WHERE plan_id = ? ORDER BY sort_order ASC, id ASC").all(planId);
+    this.normalizeStepsInPlace(steps);
+  }
+  normalizeStepsInPlace(steps) {
+    const now = Date.now();
+    steps.forEach((step, idx) => {
+      const desired = idx + 1;
+      if (step.sort_order !== desired) {
+        this.db.prepare("UPDATE steps SET sort_order = ?, updated_at = ? WHERE id = ?").run(desired, now, step.id);
+        step.sort_order = desired;
+        step.updated_at = now;
+      }
+    });
+  }
+  clearActivePlansForPlanWithConn(planId) {
+    const existing = this.db.prepare("SELECT * FROM active_plan WHERE plan_id = ?").all(planId);
+    const clearedCurrent = existing.some((row) => row.session_id === this.sessionId);
+    this.db.prepare("DELETE FROM active_plan WHERE plan_id = ?").run(planId);
+    return clearedCurrent;
+  }
+};
+
+// src/prompt.ts
+var PLANPILOT_HELP_TEXT = [
+  "Planpilot - Plan/Step/Goal auto-continue workflow.",
+  "",
+  "Model:",
+  "- plan -> step -> goal",
+  "- step.executor: ai | human",
+  "- status rolls up: goals -> steps -> plan",
+  "",
+  "Rules (important):",
+  "- Prefer assigning steps to ai. Use human steps only for actions that require human approval/credentials",
+  "  or elevated permissions / destructive operations (e.g. GitHub web UI, sudo, deleting data/files).",
+  "- One step = one executor. Do NOT mix ai/human work within the same step.",
+  "  If a person must do something, create a separate human step.",
+  "- Keep statuses up to date. Mark goals/steps done as soon as they are completed so roll-up and auto-continue stay correct.",
+  "- `step wait` is ONLY for asynchronous, non-blocking external work that is already in progress",
+  "  (build/test/job/CI/network/remote service).",
+  "  If you can run something now, do it instead of waiting.",
+  "  Do NOT use `step wait` to wait for human action.",
+  "- Keep comments short and decision-focused.",
+  "",
+  "Status propagation:",
+  "- Step with goals: done iff ALL goals are done; else todo.",
+  "- Plan with steps: done iff ALL steps are done; else todo.",
+  "- Step with 0 goals: manual status (`step update` / `step done`).",
+  "- Plan with 0 steps: manual status (`plan update` / `plan done`).",
+  "- When a plan becomes done, it is removed from active plan.",
+  "",
+  "Auto-continue:",
+  "- When the session is idle and an active plan exists:",
+  "  - if next pending step.executor is ai: Planpilot auto-sends the next step + goals.",
+  "  - if next pending step.executor is human: no auto-continue.",
+  "- Pause while waiting on external systems: `step wait`.",
+  "- Stop auto-continue:",
+  "  - `plan deactivate`, OR",
+  "  - insert a human step BEFORE the next pending ai step (so the next executor becomes human).",
+  "",
+  "Invocation:",
+  "- argv is tokenized: [section, subcommand, ...args]",
+  "- section: help | plan | step | goal",
+  "",
+  "Commands:",
+  "- help",
+  "",
+  "Plan:",
+  "- plan add-tree <title> <content> --step <content> [--executor ai|human] [--goal <content>]... [--step ...]...",
+  "- plan list [--scope project|all] [--status todo|done|all] [--limit N] [--page N] [--order id|title|created|updated] [--desc]",
+  "- plan count [--scope project|all] [--status todo|done|all]",
+  "- plan search --search <term> [--search <term> ...] [--search-mode any|all] [--search-field plan|title|content|comment|steps|goals|all] [--match-case] [--scope project|all] [--status todo|done|all] [--limit N] [--page N] [--order id|title|created|updated] [--desc]",
+  "- plan show <id>",
+  "- plan export <id> <path>",
+  "- plan comment <id> <comment> [<id> <comment> ...]",
+  "- plan update <id> [--title <title>] [--content <content>] [--status todo|done] [--comment <comment>]",
+  "- plan done <id>",
+  "- plan remove <id>",
+  "- plan activate <id> [--force]",
+  "- plan show-active",
+  "- plan deactivate",
+  "",
+  "Step:",
+  "- step add <plan_id> <content...> [--executor ai|human] [--at <pos>]",
+  "- step add-tree <plan_id> <content> [--executor ai|human] [--goal <content> ...]",
+  "- step list <plan_id> [--status todo|done|all] [--executor ai|human] [--limit N] [--page N]",
+  "- step count <plan_id> [--status todo|done|all] [--executor ai|human]",
+  "- step show <id>",
+  "- step show-next",
+  "- step wait <id> --delay <ms> [--reason <text>]",
+  "- step wait <id> --clear",
+  "- step comment <id> <comment> [<id> <comment> ...]",
+  "- step update <id> [--content <content>] [--status todo|done] [--executor ai|human] [--comment <comment>]",
+  "- step done <id> [--all-goals]",
+  "- step move <id> --to <pos>",
+  "- step remove <id...>",
+  "",
+  "Goal:",
+  "- goal add <step_id> <content...>",
+  "- goal list <step_id> [--status todo|done|all] [--limit N] [--page N]",
+  "- goal count <step_id> [--status todo|done|all]",
+  "- goal show <id>",
+  "- goal comment <id> <comment> [<id> <comment> ...]",
+  "- goal update <id> [--content <content>] [--status todo|done] [--comment <comment>]",
+  "- goal done <id...>",
+  "- goal remove <id...>"
+].join("\n");
+var PLANPILOT_TOOL_DESCRIPTION = [
+  "Planpilot planner for auto-continue plan workflows.",
+  "For multi-step and complex tasks, use Planpilot to structure work into plans/steps/goals.",
+  "Run `planpilot help` for full usage + rules."
+].join("\n");
+var PLANPILOT_SYSTEM_INJECTION = "If the task is multi-step or complex, must use the `planpilot` plan tool. For full usage + rules, run: planpilot help.";
+function formatPlanpilotAutoContinueMessage(input) {
+  const detail = (input.stepDetail ?? "").trimEnd();
+  const trigger = (input.triggerDetail ?? "").trim();
+  return [
+    `Planpilot @ ${input.timestamp}`,
+    "This message was automatically sent by the Planpilot tool because the next pending step executor is ai.",
+    ...trigger ? [`Trigger context: ${trigger}`] : [],
+    "For full usage + rules, run: planpilot help",
+    "Next step details:",
+    detail
+  ].join("\n");
+}
+
+// src/command.ts
+var DEFAULT_PAGE = 1;
+var DEFAULT_LIMIT = 20;
+var noopIO = {
+  log: () => {
+  }
+};
+var currentIO = noopIO;
+function log(...args) {
+  currentIO.log(...args);
+}
+async function withIO(io, fn) {
+  const prev = currentIO;
+  currentIO = io;
+  try {
+    return await fn();
+  } finally {
+    currentIO = prev;
+  }
+}
+function formatCommandError(err) {
+  if (err instanceof AppError) {
+    return `Error: ${err.toDisplayString()}`;
+  }
+  if (err instanceof Error) {
+    return `Error: ${err.message}`;
+  }
+  return `Error: ${String(err)}`;
+}
+async function runCommand(argv, context, io = noopIO) {
+  return withIO(io, async () => {
+    if (!argv.length) {
+      throw invalidInput("missing argv");
+    }
+    const [section, subcommand, ...args] = argv;
+    const db = openDatabase();
+    const resolvedCwd = resolveMaybeRealpath(context.cwd);
+    const app = new PlanpilotApp(db, context.sessionId, resolvedCwd);
+    let planIds = [];
+    let shouldSync = false;
+    switch (section) {
+      case "help": {
+        if (subcommand !== void 0 || args.length) {
+          const rest = [subcommand, ...args].filter((x) => x !== void 0);
+          throw invalidInput(`help unexpected argument: ${rest.join(" ")}`);
+        }
+        log(PLANPILOT_HELP_TEXT);
+        return;
+      }
+      case "plan": {
+        const result = await handlePlan(app, subcommand, args, { cwd: context.cwd });
+        planIds = result.planIds;
+        shouldSync = result.shouldSync;
+        break;
+      }
+      case "step": {
+        const result = await handleStep(app, subcommand, args);
+        planIds = result.planIds;
+        shouldSync = result.shouldSync;
+        break;
+      }
+      case "goal": {
+        const result = await handleGoal(app, subcommand, args);
+        planIds = result.planIds;
+        shouldSync = result.shouldSync;
+        break;
+      }
+      default:
+        throw invalidInput(`unknown command: ${section}`);
+    }
+    if (shouldSync) {
+      syncPlanMarkdown(app, planIds);
+    }
+  });
+}
+function requireCwd(cwd) {
+  if (!cwd || !cwd.trim()) {
+    throw invalidInput("cwd is required");
+  }
+  return cwd;
+}
+async function handlePlan(app, subcommand, args, context) {
+  switch (subcommand) {
+    case "add-tree":
+      return { planIds: handlePlanAddTree(app, args), shouldSync: true };
+    case "list":
+      return { planIds: handlePlanList(app, args, context), shouldSync: false };
+    case "count":
+      return { planIds: handlePlanCount(app, args, context), shouldSync: false };
+    case "search":
+      return { planIds: handlePlanSearch(app, args, context), shouldSync: false };
+    case "show":
+      return { planIds: handlePlanShow(app, args), shouldSync: false };
+    case "export":
+      return { planIds: handlePlanExport(app, args), shouldSync: false };
+    case "comment":
+      return { planIds: handlePlanComment(app, args), shouldSync: true };
+    case "update":
+      return { planIds: handlePlanUpdate(app, args), shouldSync: true };
+    case "done":
+      return { planIds: handlePlanDone(app, args), shouldSync: true };
+    case "remove":
+      return { planIds: handlePlanRemove(app, args), shouldSync: true };
+    case "activate":
+      return { planIds: handlePlanActivate(app, args), shouldSync: true };
+    case "show-active":
+      return { planIds: handlePlanActive(app), shouldSync: false };
+    case "deactivate":
+      return { planIds: handlePlanDeactivate(app), shouldSync: true };
+    default:
+      throw invalidInput(`unknown plan command: ${subcommand ?? ""}`);
+  }
+}
+async function handleStep(app, subcommand, args) {
+  switch (subcommand) {
+    case "add":
+      return { planIds: handleStepAdd(app, args), shouldSync: true };
+    case "add-tree":
+      return { planIds: handleStepAddTree(app, args), shouldSync: true };
+    case "list":
+      return { planIds: handleStepList(app, args), shouldSync: false };
+    case "count":
+      return { planIds: handleStepCount(app, args), shouldSync: false };
+    case "show":
+      return { planIds: handleStepShow(app, args), shouldSync: false };
+    case "show-next":
+      return { planIds: handleStepShowNext(app), shouldSync: false };
+    case "wait":
+      return { planIds: handleStepWait(app, args), shouldSync: true };
+    case "comment":
+      return { planIds: handleStepComment(app, args), shouldSync: true };
+    case "update":
+      return { planIds: handleStepUpdate(app, args), shouldSync: true };
+    case "done":
+      return { planIds: handleStepDone(app, args), shouldSync: true };
+    case "move":
+      return { planIds: handleStepMove(app, args), shouldSync: true };
+    case "remove":
+      return { planIds: handleStepRemove(app, args), shouldSync: true };
+    default:
+      throw invalidInput(`unknown step command: ${subcommand ?? ""}`);
+  }
+}
+async function handleGoal(app, subcommand, args) {
+  switch (subcommand) {
+    case "add":
+      return { planIds: handleGoalAdd(app, args), shouldSync: true };
+    case "list":
+      return { planIds: handleGoalList(app, args), shouldSync: false };
+    case "count":
+      return { planIds: handleGoalCount(app, args), shouldSync: false };
+    case "show":
+      return { planIds: handleGoalShow(app, args), shouldSync: false };
+    case "comment":
+      return { planIds: handleGoalComment(app, args), shouldSync: true };
+    case "update":
+      return { planIds: handleGoalUpdate(app, args), shouldSync: true };
+    case "done":
+      return { planIds: handleGoalDone(app, args), shouldSync: true };
+    case "remove":
+      return { planIds: handleGoalRemove(app, args), shouldSync: true };
+    default:
+      throw invalidInput(`unknown goal command: ${subcommand ?? ""}`);
+  }
+}
+function handlePlanAddTree(app, args) {
+  const [title, content, ...rest] = args;
+  if (!title || content === void 0) {
+    throw invalidInput("plan add-tree requires <title> <content> and at least one --step");
+  }
+  ensureNonEmpty("plan title", title);
+  ensureNonEmpty("plan content", content);
+  const specs = parsePlanAddTreeSteps(rest);
+  if (!specs.length) {
+    throw invalidInput("plan add-tree requires at least one --step");
+  }
+  const steps = specs.map((spec) => ({
+    content: spec.content,
+    executor: spec.executor ?? "ai",
+    goals: spec.goals ?? []
+  }));
+  const result = app.addPlanTree({ title, content }, steps);
+  log(`Created plan ID: ${result.plan.id}: ${result.plan.title} (steps: ${result.stepCount}, goals: ${result.goalCount})`);
+  app.setActivePlan(result.plan.id, false);
+  log(`Active plan set to ${result.plan.id}: ${result.plan.title}`);
+  const detail = app.getPlanDetail(result.plan.id);
+  log("");
+  log(formatPlanDetail(detail.plan, detail.steps, detail.goals));
+  return [result.plan.id];
+}
+function handlePlanList(app, args, context) {
+  const { options, positionals } = parseOptions(args);
+  if (positionals.length) {
+    throw invalidInput(`plan list unexpected argument: ${positionals.join(" ")}`);
+  }
+  if (options.search && options.search.length) {
+    throw invalidInput("plan list does not accept --search");
+  }
+  const allowed = /* @__PURE__ */ new Set(["scope", "status", "limit", "page", "order", "desc", "search"]);
+  for (const key of Object.keys(options)) {
+    if (!allowed.has(key)) {
+      throw invalidInput(`plan list does not support --${key}`);
+    }
+  }
+  const desiredStatus = parsePlanStatusFilter(options.status);
+  const cwd = requireCwd(context.cwd);
+  const order = options.order ? parsePlanOrder(options.order) : "updated";
+  const desc = options.desc ?? true;
+  let plans = app.listPlans(order, desc);
+  if (!plans.length) {
+    log("No plans found.");
+    return [];
+  }
+  plans = plans.filter((plan) => desiredStatus ? plan.status === desiredStatus : true);
+  const scope = parseScope(options.scope);
+  if (scope === "project") {
+    const cwdValue = resolveMaybeRealpath(cwd);
+    plans = plans.filter((plan) => plan.last_cwd && projectMatchesPath(plan.last_cwd, cwdValue));
+  }
+  if (!plans.length) {
+    log("No plans found.");
+    return [];
+  }
+  const pagination = resolvePagination(options, { limit: DEFAULT_LIMIT, page: DEFAULT_PAGE });
+  const total = plans.length;
+  if (total === 0) {
+    log("No plans found.");
+    return [];
+  }
+  const totalPages = Math.ceil(total / pagination.limit);
+  if (pagination.page > totalPages) {
+    log(`Page ${pagination.page} exceeds total pages ${totalPages}.`);
+    return [];
+  }
+  const start = pagination.offset;
+  const end = start + pagination.limit;
+  plans = plans.slice(start, end);
+  const details = app.getPlanDetails(plans);
+  printPlanList(details);
+  logPageFooter(pagination.page, pagination.limit);
+  return [];
+}
+function handlePlanCount(app, args, context) {
+  const { options, positionals } = parseOptions(args);
+  if (positionals.length) {
+    throw invalidInput(`plan count unexpected argument: ${positionals.join(" ")}`);
+  }
+  if (options.search && options.search.length) {
+    throw invalidInput("plan count does not accept --search");
+  }
+  const allowed = /* @__PURE__ */ new Set(["scope", "status", "search"]);
+  for (const key of Object.keys(options)) {
+    if (!allowed.has(key)) {
+      throw invalidInput(`plan count does not support --${key}`);
+    }
+  }
+  const desiredStatus = parsePlanStatusFilter(options.status);
+  const cwd = requireCwd(context.cwd);
+  let plans = app.listPlans();
+  if (!plans.length) {
+    log("Total: 0");
+    return [];
+  }
+  plans = plans.filter((plan) => desiredStatus ? plan.status === desiredStatus : true);
+  const scope = parseScope(options.scope);
+  if (scope === "project") {
+    const cwdValue = resolveMaybeRealpath(cwd);
+    plans = plans.filter((plan) => plan.last_cwd && projectMatchesPath(plan.last_cwd, cwdValue));
+  }
+  log(`Total: ${plans.length}`);
+  return [];
+}
+function handlePlanSearch(app, args, context) {
+  const { options, positionals } = parseOptions(args);
+  if (positionals.length) {
+    throw invalidInput(`plan search unexpected argument: ${positionals.join(" ")}`);
+  }
+  if (options.search && !options.search.length) {
+    throw invalidInput("plan search requires at least one --search");
+  }
+  const desiredStatus = parsePlanStatusFilter(options.status);
+  const cwd = requireCwd(context.cwd);
+  const order = options.order ? parsePlanOrder(options.order) : "updated";
+  const desc = options.desc ?? true;
+  let plans = app.listPlans(order, desc);
+  if (!plans.length) {
+    log("No plans found.");
+    return [];
+  }
+  plans = plans.filter((plan) => desiredStatus ? plan.status === desiredStatus : true);
+  const scope = parseScope(options.scope);
+  if (scope === "project") {
+    const cwdValue = resolveMaybeRealpath(cwd);
+    plans = plans.filter((plan) => plan.last_cwd && projectMatchesPath(plan.last_cwd, cwdValue));
+  }
+  if (!plans.length) {
+    log("No plans found.");
+    return [];
+  }
+  const details = app.getPlanDetails(plans);
+  const query = new PlanSearchQuery(options.search, options.searchMode, options.searchField, options.matchCase);
+  const filtered = details.filter((detail) => planMatchesSearch(detail, query));
+  if (!filtered.length) {
+    log("No plans found.");
+    return [];
+  }
+  const pagination = resolvePagination(options, { limit: DEFAULT_LIMIT, page: DEFAULT_PAGE });
+  const totalPages = Math.ceil(filtered.length / pagination.limit);
+  if (pagination.page > totalPages) {
+    log(`Page ${pagination.page} exceeds total pages ${totalPages}.`);
+    return [];
+  }
+  const start = pagination.offset;
+  const end = start + pagination.limit;
+  const paged = filtered.slice(start, end);
+  printPlanList(paged);
+  logPageFooter(pagination.page, pagination.limit);
+  return [];
+}
+function handlePlanShow(app, args) {
+  const id = parseIdArg(args, "plan show");
+  const detail = app.getPlanDetail(id);
+  log(formatPlanDetail(detail.plan, detail.steps, detail.goals));
+  return [];
+}
+function handlePlanExport(app, args) {
+  if (args.length < 2) {
+    throw invalidInput("plan export requires <id> <path>");
+  }
+  const id = parseNumber(args[0], "plan id");
+  const filePath = args[1];
+  const detail = app.getPlanDetail(id);
+  const active = app.getActivePlan();
+  const isActive = active?.plan_id === detail.plan.id;
+  const activatedAt = isActive ? active?.updated_at ?? null : null;
+  ensureParentDir(filePath);
+  const markdown = formatPlanMarkdown(isActive, activatedAt ?? null, detail.plan, detail.steps, detail.goals);
+  fs3.writeFileSync(filePath, markdown, "utf8");
+  log(`Exported plan ID: ${detail.plan.id} to ${filePath}`);
+  return [];
+}
+function handlePlanComment(app, args) {
+  const entries = parseCommentPairs("plan", args);
+  const planIds = app.commentPlans(entries);
+  if (planIds.length === 1) {
+    log(`Updated plan comment for plan ID: ${planIds[0]}.`);
+  } else {
+    log(`Updated plan comments for ${planIds.length} plans.`);
+  }
+  return planIds;
+}
+function handlePlanUpdate(app, args) {
+  if (!args.length) {
+    throw invalidInput("plan update requires <id>");
+  }
+  const id = parseNumber(args[0], "plan id");
+  const { options } = parseOptions(args.slice(1));
+  if (options.content !== void 0) {
+    ensureNonEmpty("plan content", options.content);
+  }
+  const changes = {
+    title: options.title,
+    content: options.content,
+    status: options.status ? parsePlanStatus(options.status) : void 0,
+    comment: options.comment
+  };
+  const result = app.updatePlanWithActiveClear(id, changes);
+  log(`Updated plan ID: ${result.plan.id}: ${result.plan.title}`);
+  if (result.cleared) {
+    log("Active plan deactivated because plan is done.");
+  }
+  if (result.plan.status === "done") {
+    notifyPlanCompleted(result.plan.id);
+  }
+  return [result.plan.id];
+}
+function handlePlanDone(app, args) {
+  const id = parseIdArg(args, "plan done");
+  const result = app.updatePlanWithActiveClear(id, { status: "done" });
+  log(`Plan ID: ${result.plan.id} marked done.`);
+  if (result.cleared) {
+    log("Active plan deactivated because plan is done.");
+  }
+  if (result.plan.status === "done") {
+    notifyPlanCompleted(result.plan.id);
+  }
+  return [result.plan.id];
+}
+function handlePlanRemove(app, args) {
+  const id = parseIdArg(args, "plan remove");
+  app.deletePlan(id);
+  log(`Plan ID: ${id} removed.`);
+  return [];
+}
+function handlePlanActivate(app, args) {
+  if (!args.length) {
+    throw invalidInput("plan activate requires <id>");
+  }
+  const id = parseNumber(args[0], "plan id");
+  const force = args.slice(1).includes("--force");
+  const plan = app.getPlan(id);
+  if (plan.status === "done") {
+    throw invalidInput("cannot activate plan; plan is done");
+  }
+  app.setActivePlan(id, force);
+  log(`Active plan set to ${plan.id}: ${plan.title}`);
+  return [plan.id];
+}
+function handlePlanActive(app) {
+  const active = app.getActivePlan();
+  if (!active) {
+    log("No active plan.");
+    return [];
+  }
+  try {
+    const detail = app.getPlanDetail(active.plan_id);
+    log(formatPlanDetail(detail.plan, detail.steps, detail.goals));
+    return [];
+  } catch (err) {
+    if (err instanceof AppError && err.kind === "NotFound") {
+      app.clearActivePlan();
+      log(`Active plan ID: ${active.plan_id} not found.`);
+      return [];
+    }
+    throw err;
+  }
+}
+function handlePlanDeactivate(app) {
+  const active = app.getActivePlan();
+  app.clearActivePlan();
+  log("Active plan deactivated.");
+  return active ? [active.plan_id] : [];
+}
+function handleStepAdd(app, args) {
+  if (args.length < 2) {
+    throw invalidInput("step add requires <plan_id> <content...>");
+  }
+  const planId = parseNumber(args[0], "plan id");
+  const parsed = parseStepAddArgs(args.slice(1));
+  if (!parsed.contents.length) {
+    throw invalidInput("no contents provided");
+  }
+  if (parsed.at !== void 0 && parsed.at === 0) {
+    throw invalidInput("position starts at 1");
+  }
+  parsed.contents.forEach((content) => ensureNonEmpty("step content", content));
+  const result = app.addStepsBatch(planId, parsed.contents, "todo", parsed.executor ?? "ai", parsed.at);
+  if (result.steps.length === 1) {
+    log(`Created step ID: ${result.steps[0].id} for plan ID: ${result.steps[0].plan_id}`);
+  } else {
+    log(`Created ${result.steps.length} steps for plan ID: ${planId}`);
+  }
+  printStatusChanges(result.changes);
+  return [planId];
+}
+function handleStepAddTree(app, args) {
+  if (args.length < 2) {
+    throw invalidInput("step add-tree requires <plan_id> <content>");
+  }
+  const planId = parseNumber(args[0], "plan id");
+  const content = args[1];
+  const parsed = parseStepAddTreeArgs(args.slice(2));
+  ensureNonEmpty("step content", content);
+  parsed.goals.forEach((goal) => ensureNonEmpty("goal content", goal));
+  const executor = parsed.executor ?? "ai";
+  const result = app.addStepTree(planId, content, executor, parsed.goals);
+  log(`Created step ID: ${result.step.id} for plan ID: ${result.step.plan_id} (goals: ${result.goals.length})`);
+  printStatusChanges(result.changes);
+  notifyAfterStepChanges(app, result.changes);
+  notifyPlansCompleted(app, result.changes);
+  return [planId];
+}
+function handleStepList(app, args) {
+  if (!args.length) {
+    throw invalidInput("step list requires <plan_id>");
+  }
+  const planId = parseNumber(args[0], "plan id");
+  const { options } = parseOptions(args.slice(1));
+  const allowed = /* @__PURE__ */ new Set(["status", "executor", "limit", "page"]);
+  for (const key of Object.keys(options)) {
+    if (key === "search" && Array.isArray(options.search) && options.search.length === 0) continue;
+    if (!allowed.has(key)) {
+      throw invalidInput(`step list does not support --${key}`);
+    }
+  }
+  const status = parseStepStatusFilter(options.status);
+  const pagination = resolvePagination(options, { limit: DEFAULT_LIMIT, page: DEFAULT_PAGE });
+  const countQuery = {
+    status,
+    executor: options.executor ? parseStepExecutor(options.executor) : void 0,
+    limit: void 0,
+    offset: void 0,
+    order: void 0,
+    desc: void 0
+  };
+  const total = app.countSteps(planId, countQuery);
+  if (total === 0) {
+    log(`No steps found for plan ID: ${planId}.`);
+    return [];
+  }
+  const totalPages = Math.ceil(total / pagination.limit);
+  if (pagination.page > totalPages) {
+    log(`Page ${pagination.page} exceeds total pages ${totalPages} for plan ID: ${planId}.`);
+    return [];
+  }
+  const query = {
+    status,
+    executor: options.executor ? parseStepExecutor(options.executor) : void 0,
+    limit: pagination.limit,
+    offset: pagination.offset,
+    order: "order",
+    desc: false
+  };
+  const steps = app.listStepsFiltered(planId, query);
+  const details = app.getStepsDetail(steps);
+  printStepList(details);
+  logPageFooter(pagination.page, pagination.limit);
+  return [];
+}
+function handleStepCount(app, args) {
+  if (!args.length) {
+    throw invalidInput("step count requires <plan_id>");
+  }
+  const planId = parseNumber(args[0], "plan id");
+  const { options } = parseOptions(args.slice(1));
+  const allowed = /* @__PURE__ */ new Set(["status", "executor"]);
+  for (const key of Object.keys(options)) {
+    if (key === "search" && Array.isArray(options.search) && options.search.length === 0) continue;
+    if (!allowed.has(key)) {
+      throw invalidInput(`step count does not support --${key}`);
+    }
+  }
+  const status = parseStepStatusFilter(options.status);
+  const query = {
+    status,
+    executor: options.executor ? parseStepExecutor(options.executor) : void 0,
+    limit: void 0,
+    offset: void 0,
+    order: void 0,
+    desc: void 0
+  };
+  const total = app.countSteps(planId, query);
+  log(`Total: ${total}`);
+  return [];
+}
+function handleStepShow(app, args) {
+  const id = parseIdArg(args, "step show");
+  const detail = app.getStepDetail(id);
+  log(formatStepDetail(detail.step, detail.goals));
+  return [];
+}
+function handleStepShowNext(app) {
+  const active = app.getActivePlan();
+  if (!active) {
+    log("No active plan.");
+    return [];
+  }
+  const next = app.nextStep(active.plan_id);
+  if (!next) {
+    log("No pending step.");
+    return [];
+  }
+  const goals = app.goalsForStep(next.id);
+  log(formatStepDetail(next, goals));
+  return [];
+}
+function handleStepWait(app, args) {
+  if (!args.length) {
+    throw invalidInput("step wait requires <id>");
+  }
+  const stepId = parseNumber(args[0], "step id");
+  const options = parseOptions(args.slice(1)).options;
+  if (options.clear) {
+    const result2 = app.clearStepWait(stepId);
+    log(`Step ID: ${result2.step.id} wait cleared.`);
+    return [result2.step.plan_id];
+  }
+  if (options.delay === void 0) {
+    throw invalidInput("step wait requires --delay <ms> or --clear");
+  }
+  const delayMs = parseNumber(options.delay, "delay");
+  if (delayMs < 0) {
+    throw invalidInput("delay must be >= 0");
+  }
+  const reason = options.reason ? String(options.reason) : void 0;
+  const result = app.setStepWait(stepId, delayMs, reason);
+  log(`Step ID: ${result.step.id} waiting until ${result.until}.`);
+  return [result.step.plan_id];
+}
+function handleStepUpdate(app, args) {
+  if (!args.length) {
+    throw invalidInput("step update requires <id>");
+  }
+  const id = parseNumber(args[0], "step id");
+  const { options } = parseOptions(args.slice(1));
+  if (options.content !== void 0) {
+    ensureNonEmpty("step content", options.content);
+  }
+  const status = options.status ? parseStepStatus(options.status) : void 0;
+  const result = app.updateStep(id, {
+    content: options.content,
+    status,
+    executor: options.executor ? parseStepExecutor(options.executor) : void 0,
+    comment: options.comment
+  });
+  log(`Updated step ID: ${result.step.id}.`);
+  printStatusChanges(result.changes);
+  if (status === "done" && result.step.status === "done") {
+    notifyNextStepForPlan(app, result.step.plan_id);
+  }
+  notifyPlansCompleted(app, result.changes);
+  return [result.step.plan_id];
+}
+function handleStepComment(app, args) {
+  const entries = parseCommentPairs("step", args);
+  const planIds = app.commentSteps(entries);
+  if (planIds.length === 1) {
+    log(`Updated step comments for plan ID: ${planIds[0]}.`);
+  } else {
+    log(`Updated step comments for ${planIds.length} plans.`);
+  }
+  return planIds;
+}
+function handleStepDone(app, args) {
+  if (!args.length) {
+    throw invalidInput("step done requires <id>");
+  }
+  const id = parseNumber(args[0], "step id");
+  const allGoals = args.slice(1).includes("--all-goals");
+  const result = app.setStepDoneWithGoals(id, allGoals);
+  log(`Step ID: ${result.step.id} marked done.`);
+  printStatusChanges(result.changes);
+  notifyNextStepForPlan(app, result.step.plan_id);
+  notifyPlansCompleted(app, result.changes);
+  return [result.step.plan_id];
+}
+function handleStepMove(app, args) {
+  if (!args.length) {
+    throw invalidInput("step move requires <id> --to <pos>");
+  }
+  const id = parseNumber(args[0], "step id");
+  const toIndex = args.indexOf("--to");
+  if (toIndex === -1 || toIndex === args.length - 1) {
+    throw invalidInput("step move requires --to <pos>");
+  }
+  const to = parseNumber(args[toIndex + 1], "position");
+  if (to === 0) {
+    throw invalidInput("position starts at 1");
+  }
+  const steps = app.moveStep(id, to);
+  log(`Reordered steps for plan ID: ${steps[0].plan_id}:`);
+  const details = app.getStepsDetail(steps);
+  printStepList(details);
+  return [steps[0].plan_id];
+}
+function handleStepRemove(app, args) {
+  if (!args.length) {
+    throw invalidInput("no step ids provided");
+  }
+  const ids = args.map((arg) => parseNumber(arg, "step id"));
+  const planIds = app.planIdsForSteps(ids);
+  const result = app.deleteSteps(ids);
+  if (ids.length === 1) {
+    log(`Step ID: ${ids[0]} removed.`);
+  } else {
+    log(`Removed ${result.deleted} steps.`);
+  }
+  printStatusChanges(result.changes);
+  return planIds;
+}
+function handleGoalAdd(app, args) {
+  if (args.length < 2) {
+    throw invalidInput("goal add requires <step_id> <content...>");
+  }
+  const stepId = parseNumber(args[0], "step id");
+  const contents = args.slice(1);
+  if (!contents.length) {
+    throw invalidInput("no contents provided");
+  }
+  contents.forEach((content) => ensureNonEmpty("goal content", content));
+  const result = app.addGoalsBatch(stepId, contents, "todo");
+  if (result.goals.length === 1) {
+    log(`Created goal ID: ${result.goals[0].id} for step ID: ${result.goals[0].step_id}`);
+  } else {
+    log(`Created ${result.goals.length} goals for step ID: ${stepId}`);
+  }
+  printStatusChanges(result.changes);
+  notifyAfterStepChanges(app, result.changes);
+  notifyPlansCompleted(app, result.changes);
+  const step = app.getStep(stepId);
+  return [step.plan_id];
+}
+function handleGoalList(app, args) {
+  if (!args.length) {
+    throw invalidInput("goal list requires <step_id>");
+  }
+  const stepId = parseNumber(args[0], "step id");
+  const { options } = parseOptions(args.slice(1));
+  const status = parseGoalStatusFilter(options.status);
+  const pagination = resolvePagination(options, { limit: DEFAULT_LIMIT, page: DEFAULT_PAGE });
+  const countQuery = {
+    status,
+    limit: void 0,
+    offset: void 0
+  };
+  const total = app.countGoals(stepId, countQuery);
+  if (total === 0) {
+    log(`No goals found for step ID: ${stepId}.`);
+    return [];
+  }
+  const totalPages = Math.ceil(total / pagination.limit);
+  if (pagination.page > totalPages) {
+    log(`Page ${pagination.page} exceeds total pages ${totalPages} for step ID: ${stepId}.`);
+    return [];
+  }
+  const query = {
+    status,
+    limit: pagination.limit,
+    offset: pagination.offset
+  };
+  const goals = app.listGoalsFiltered(stepId, query);
+  printGoalList(goals);
+  logPageFooter(pagination.page, pagination.limit);
+  return [];
+}
+function handleGoalCount(app, args) {
+  if (!args.length) {
+    throw invalidInput("goal count requires <step_id>");
+  }
+  const stepId = parseNumber(args[0], "step id");
+  const { options } = parseOptions(args.slice(1));
+  const status = parseGoalStatusFilter(options.status);
+  const query = {
+    status,
+    limit: void 0,
+    offset: void 0
+  };
+  const total = app.countGoals(stepId, query);
+  log(`Total: ${total}`);
+  return [];
+}
+function handleGoalShow(app, args) {
+  const id = parseIdArg(args, "goal show");
+  const detail = app.getGoalDetail(id);
+  log(formatGoalDetail(detail.goal, detail.step));
+  return [];
+}
+function handleGoalComment(app, args) {
+  const entries = parseCommentPairs("goal", args);
+  const planIds = app.commentGoals(entries);
+  if (planIds.length === 1) {
+    log(`Updated goal comments for plan ID: ${planIds[0]}.`);
+  } else {
+    log(`Updated goal comments for ${planIds.length} plans.`);
+  }
+  return planIds;
+}
+function handleGoalUpdate(app, args) {
+  if (!args.length) {
+    throw invalidInput("goal update requires <id>");
+  }
+  const id = parseNumber(args[0], "goal id");
+  const { options } = parseOptions(args.slice(1));
+  if (options.content !== void 0) {
+    ensureNonEmpty("goal content", options.content);
+  }
+  const result = app.updateGoal(id, {
+    content: options.content,
+    status: options.status ? parseGoalStatus(options.status) : void 0,
+    comment: options.comment
+  });
+  log(`Updated goal ${result.goal.id}.`);
+  printStatusChanges(result.changes);
+  notifyAfterStepChanges(app, result.changes);
+  notifyPlansCompleted(app, result.changes);
+  const step = app.getStep(result.goal.step_id);
+  return [step.plan_id];
+}
+function handleGoalDone(app, args) {
+  if (!args.length) {
+    throw invalidInput("goal done requires <id>");
+  }
+  const ids = args.map((arg) => parseNumber(arg, "goal id"));
+  if (ids.length === 1) {
+    const result2 = app.setGoalStatus(ids[0], "done");
+    log(`Goal ID: ${result2.goal.id} marked done.`);
+    printStatusChanges(result2.changes);
+    notifyAfterStepChanges(app, result2.changes);
+    notifyPlansCompleted(app, result2.changes);
+    const step = app.getStep(result2.goal.step_id);
+    return [step.plan_id];
+  }
+  const planIds = app.planIdsForGoals(ids);
+  const result = app.setGoalsStatus(ids, "done");
+  log(`Goals marked done: ${result.updated}.`);
+  printStatusChanges(result.changes);
+  notifyAfterStepChanges(app, result.changes);
+  notifyPlansCompleted(app, result.changes);
+  return planIds;
+}
+function handleGoalRemove(app, args) {
+  if (!args.length) {
+    throw invalidInput("no goal ids provided");
+  }
+  const ids = args.map((arg) => parseNumber(arg, "goal id"));
+  const planIds = app.planIdsForGoals(ids);
+  const result = app.deleteGoals(ids);
+  if (ids.length === 1) {
+    log(`Goal ID: ${ids[0]} removed.`);
+  } else {
+    log(`Removed ${result.deleted} goals.`);
+  }
+  printStatusChanges(result.changes);
+  notifyAfterStepChanges(app, result.changes);
+  notifyPlansCompleted(app, result.changes);
+  return planIds;
+}
+function parseIdArg(args, label) {
+  if (!args.length) {
+    throw invalidInput(`${label} requires <id>`);
+  }
+  return parseNumber(args[0], "id");
+}
+function parseNumber(value, label) {
+  const num = Number(value);
+  if (!Number.isFinite(num) || !Number.isInteger(num)) {
+    throw invalidInput(`${label} '${value}' is invalid`);
+  }
+  return num;
+}
+function parseOptions(args) {
+  const options = { search: [] };
+  const positionals = [];
+  let i = 0;
+  while (i < args.length) {
+    const token = args[i];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      i += 1;
+      continue;
+    }
+    switch (token) {
+      case "--scope":
+        options.scope = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--match-case":
+        options.matchCase = true;
+        i += 1;
+        break;
+      case "--desc":
+        options.desc = true;
+        i += 1;
+        break;
+      case "--all-goals":
+        options.allGoals = true;
+        i += 1;
+        break;
+      case "--force":
+        options.force = true;
+        i += 1;
+        break;
+      case "--search":
+        options.search.push(expectValue(args, i, token));
+        i += 2;
+        break;
+      case "--search-mode":
+        options.searchMode = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--search-field":
+        options.searchField = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--title":
+        options.title = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--content":
+        options.content = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--status":
+        options.status = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--comment":
+        options.comment = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--executor":
+        options.executor = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--limit":
+        options.limit = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--page":
+        options.page = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--order":
+        options.order = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--to":
+        options.to = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--delay":
+        options.delay = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--reason":
+        options.reason = expectValue(args, i, token);
+        i += 2;
+        break;
+      case "--clear":
+        options.clear = true;
+        i += 1;
+        break;
+      case "--goal":
+        if (!options.goals) options.goals = [];
+        options.goals.push(expectValue(args, i, token));
+        i += 2;
+        break;
+      default:
+        throw invalidInput(`unexpected argument: ${token}`);
+    }
+  }
+  return { options, positionals };
+}
+function expectValue(args, index, token) {
+  const value = args[index + 1];
+  if (value === void 0) {
+    throw invalidInput(`${token} requires a value`);
+  }
+  return value;
+}
+function parsePlanStatus(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "todo" || normalized === "done") return normalized;
+  throw invalidInput(`invalid status '${value}', expected todo|done`);
+}
+function parsePlanStatusFilter(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "all") return null;
+  return parsePlanStatus(normalized);
+}
+function parseStepStatus(value) {
+  return parsePlanStatus(value);
+}
+function parseGoalStatus(value) {
+  return parsePlanStatus(value);
+}
+function parseStepStatusFilter(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "all") return null;
+  return parseStepStatus(normalized);
+}
+function parseGoalStatusFilter(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "all") return null;
+  return parseGoalStatus(normalized);
+}
+function parseScope(value) {
+  if (!value) return "project";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "project" || normalized === "all") return normalized;
+  throw invalidInput(`invalid scope '${value}', expected project|all`);
+}
+function parsePlanOrder(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "id" || normalized === "title" || normalized === "created" || normalized === "updated") {
+    return normalized;
+  }
+  throw invalidInput(`invalid order '${value}', expected id|title|created|updated`);
+}
+function parseStepExecutor(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "ai" || normalized === "human") return normalized;
+  throw invalidInput(`invalid executor '${value}', expected ai|human`);
+}
+function resolvePagination(options, defaults) {
+  if (defaults.limit <= 0 || defaults.page < 1) {
+    throw invalidInput("invalid default pagination configuration");
+  }
+  const limit = options.limit !== void 0 ? parseNumber(options.limit, "limit") : defaults.limit;
+  if (limit <= 0) {
+    throw invalidInput("limit must be >= 1");
+  }
+  const page = options.page !== void 0 ? parseNumber(options.page, "page") : defaults.page;
+  if (page < 1) {
+    throw invalidInput("page must be >= 1");
+  }
+  return { limit, page, offset: (page - 1) * limit };
+}
+var PlanSearchQuery = class {
+  terms;
+  mode;
+  field;
+  matchCase;
+  constructor(rawTerms = [], searchMode, searchField, matchCase) {
+    let terms = rawTerms.map((term) => term.trim()).filter((term) => term.length > 0);
+    const caseSensitive = !!matchCase;
+    if (!caseSensitive) {
+      terms = terms.map((term) => term.toLowerCase());
+    }
+    this.terms = terms;
+    this.mode = parseSearchMode(searchMode);
+    this.field = parseSearchField(searchField);
+    this.matchCase = caseSensitive;
+  }
+  hasTerms() {
+    return this.terms.length > 0;
+  }
+};
+function parseSearchMode(value) {
+  if (!value) return "all";
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "any" || normalized === "all") return normalized;
+  throw invalidInput(`invalid search mode '${value}', expected any|all`);
+}
+function parseSearchField(value) {
+  if (!value) return "plan";
+  const normalized = value.trim().toLowerCase();
+  if (["plan", "title", "content", "comment", "steps", "goals", "all"].includes(normalized)) {
+    return normalized;
+  }
+  throw invalidInput(
+    `invalid search field '${value}', expected plan|title|content|comment|steps|goals|all`
+  );
+}
+function planMatchesSearch(detail, search) {
+  const haystacks = [];
+  const addValue = (value) => {
+    haystacks.push(search.matchCase ? value : value.toLowerCase());
+  };
+  const includePlan = search.field === "plan" || search.field === "all";
+  const includeTitle = search.field === "title" || includePlan || search.field === "all";
+  const includeContent = search.field === "content" || includePlan || search.field === "all";
+  const includeComment = search.field === "comment" || includePlan || search.field === "all";
+  const includeSteps = search.field === "steps" || search.field === "all";
+  const includeGoals = search.field === "goals" || search.field === "all";
+  if (includePlan || includeTitle) addValue(detail.plan.title);
+  if (includePlan || includeContent) addValue(detail.plan.content);
+  if (includePlan || includeComment) {
+    if (detail.plan.comment) addValue(detail.plan.comment);
+  }
+  if (includeSteps) {
+    detail.steps.forEach((step) => addValue(step.content));
+  }
+  if (includeGoals) {
+    detail.goals.forEach((goalList) => goalList.forEach((goal) => addValue(goal.content)));
+  }
+  if (!haystacks.length) return false;
+  if (search.mode === "any") {
+    return search.terms.some((term) => haystacks.some((value) => value.includes(term)));
+  }
+  return search.terms.every((term) => haystacks.some((value) => value.includes(term)));
+}
+function parsePlanAddTreeSteps(args) {
+  if (!args.length) {
+    throw invalidInput("plan add-tree requires at least one --step");
+  }
+  const steps = [];
+  let current = null;
+  let i = 0;
+  while (i < args.length) {
+    const token = args[i];
+    if (token === "--") {
+      i += 1;
+      continue;
+    }
+    if (token === "--step") {
+      const value = args[i + 1];
+      if (value === void 0) {
+        throw invalidInput("plan add-tree --step requires a value");
+      }
+      if (!value.trim()) {
+        throw invalidInput("plan add-tree --step cannot be empty");
+      }
+      if (current) {
+        steps.push({ content: current.content, executor: current.executor, goals: current.goals.length ? current.goals : void 0 });
+      }
+      current = { content: value, goals: [] };
+      i += 2;
+      continue;
+    }
+    if (token === "--executor") {
+      const value = args[i + 1];
+      if (value === void 0) {
+        throw invalidInput("plan add-tree --executor requires a value");
+      }
+      if (!current) {
+        throw invalidInput("plan add-tree --executor must follow a --step");
+      }
+      current.executor = parseStepExecutor(value);
+      i += 2;
+      continue;
+    }
+    if (token === "--goal") {
+      const value = args[i + 1];
+      if (value === void 0) {
+        throw invalidInput("plan add-tree --goal requires a value");
+      }
+      if (!current) {
+        throw invalidInput("plan add-tree --goal must follow a --step");
+      }
+      current.goals.push(value);
+      i += 2;
+      continue;
+    }
+    throw invalidInput(`plan add-tree unexpected argument: ${token}`);
+  }
+  if (current) {
+    steps.push({ content: current.content, executor: current.executor, goals: current.goals.length ? current.goals : void 0 });
+  }
+  if (!steps.length) {
+    throw invalidInput("plan add-tree requires at least one --step");
+  }
+  return steps;
+}
+function parseCommentPairs(kind, pairs) {
+  if (!pairs.length) {
+    throw invalidInput(`${kind} comment requires <id> <comment> pairs`);
+  }
+  if (pairs.length % 2 !== 0) {
+    throw invalidInput(`${kind} comment expects <id> <comment> pairs`);
+  }
+  const entries = [];
+  for (let i = 0; i < pairs.length; i += 2) {
+    const idValue = pairs[i];
+    const comment = pairs[i + 1];
+    const id = parseNumber(idValue, `${kind} comment id`);
+    ensureNonEmpty("comment", comment);
+    entries.push([id, comment]);
+  }
+  return entries;
+}
+function parseStepAddArgs(args) {
+  const contents = [];
+  let executor;
+  let at;
+  let i = 0;
+  while (i < args.length) {
+    const token = args[i];
+    if (token === "--executor") {
+      const value = expectValue(args, i, token);
+      executor = parseStepExecutor(value);
+      i += 2;
+      continue;
+    }
+    if (token === "--at") {
+      const value = expectValue(args, i, token);
+      at = parseNumber(value, "position");
+      i += 2;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      throw invalidInput(`unexpected argument: ${token}`);
+    }
+    contents.push(token);
+    i += 1;
+  }
+  return { contents, executor, at };
+}
+function parseStepAddTreeArgs(args) {
+  let executor;
+  const goals = [];
+  let i = 0;
+  while (i < args.length) {
+    const token = args[i];
+    if (token === "--executor") {
+      const value = expectValue(args, i, token);
+      executor = parseStepExecutor(value);
+      i += 2;
+      continue;
+    }
+    if (token === "--goal") {
+      const value = expectValue(args, i, token);
+      goals.push(value);
+      i += 2;
+      continue;
+    }
+    throw invalidInput(`unexpected argument: ${token}`);
+  }
+  return { executor, goals };
+}
+function printStatusChanges(changes) {
+  if (statusChangesEmpty(changes)) return;
+  log("Auto status updates:");
+  changes.steps.forEach((change) => {
+    log(`- Step ID: ${change.step_id} status auto-updated from ${change.from} to ${change.to} (${change.reason}).`);
+  });
+  changes.plans.forEach((change) => {
+    log(`- Plan ID: ${change.plan_id} status auto-updated from ${change.from} to ${change.to} (${change.reason}).`);
+  });
+  changes.active_plans_cleared.forEach((change) => {
+    log(`- Active plan deactivated for plan ID: ${change.plan_id} (${change.reason}).`);
+  });
+}
+function notifyAfterStepChanges(app, changes) {
+  const planIds = /* @__PURE__ */ new Set();
+  changes.steps.forEach((change) => {
+    if (change.to === "done") {
+      const step = app.getStep(change.step_id);
+      planIds.add(step.plan_id);
+    }
+  });
+  planIds.forEach((planId) => notifyNextStepForPlan(app, planId));
+}
+function notifyPlansCompleted(app, changes) {
+  const planIds = /* @__PURE__ */ new Set();
+  changes.plans.forEach((change) => {
+    if (change.to === "done") planIds.add(change.plan_id);
+  });
+  planIds.forEach((planId) => {
+    const plan = app.getPlan(planId);
+    if (plan.status === "done") {
+      notifyPlanCompleted(plan.id);
+    }
+  });
+}
+function notifyPlanCompleted(planId) {
+  log(`Plan ID: ${planId} is complete. Summarize the completed results to the user, then end this turn.`);
+}
+function notifyNextStepForPlan(app, planId) {
+  const next = app.nextStep(planId);
+  if (!next) return;
+  if (next.executor === "ai") {
+    log(`Next step is assigned to ai (step ID: ${next.id}). Please end this turn so Planpilot can surface it.`);
+    return;
+  }
+  const goals = app.goalsForStep(next.id);
+  log("Next step requires human action:");
+  log(formatStepDetail(next, goals));
+  log(
+    "Tell the user to complete the above step and goals. Confirm each goal when done, then end this turn."
+  );
+}
+var COL_ID = 6;
+var COL_STAT = 6;
+var COL_STEPS = 9;
+var COL_ORDER = 5;
+var COL_EXEC = 6;
+var COL_GOALS = 9;
+var COL_TEXT = 30;
+function printPlanList(details) {
+  log(`${pad("ID", COL_ID)} ${pad("STAT", COL_STAT)} ${pad("STEPS", COL_STEPS)} ${pad("TITLE", COL_TEXT)} COMMENT`);
+  details.forEach((detail) => {
+    const total = detail.steps.length;
+    const done = detail.steps.filter((step) => step.status === "done").length;
+    log(
+      `${pad(String(detail.plan.id), COL_ID)} ${pad(detail.plan.status, COL_STAT)} ${pad(`${done}/${total}`, COL_STEPS)} ${pad(detail.plan.title, COL_TEXT)} ${detail.plan.comment ?? ""}`
+    );
+  });
+}
+function printStepList(details) {
+  log(
+    `${pad("ID", COL_ID)} ${pad("STAT", COL_STAT)} ${pad("ORD", COL_ORDER)} ${pad("EXEC", COL_EXEC)} ${pad("GOALS", COL_GOALS)} ${pad("CONTENT", COL_TEXT)} COMMENT`
+  );
+  details.forEach((detail) => {
+    const total = detail.goals.length;
+    const done = detail.goals.filter((goal) => goal.status === "done").length;
+    log(
+      `${pad(String(detail.step.id), COL_ID)} ${pad(detail.step.status, COL_STAT)} ${pad(String(detail.step.sort_order), COL_ORDER)} ${pad(detail.step.executor, COL_EXEC)} ${pad(`${done}/${total}`, COL_GOALS)} ${pad(detail.step.content, COL_TEXT)} ${detail.step.comment ?? ""}`
+    );
+  });
+}
+function printGoalList(goals) {
+  log(`${pad("ID", COL_ID)} ${pad("STAT", COL_STAT)} ${pad("CONTENT", COL_TEXT)} COMMENT`);
+  goals.forEach((goal) => {
+    log(`${pad(String(goal.id), COL_ID)} ${pad(goal.status, COL_STAT)} ${pad(goal.content, COL_TEXT)} ${goal.comment ?? ""}`);
+  });
+}
+function logPageFooter(page, limit) {
+  log(`Page ${page} / Limit ${limit}`);
+}
+function pad(value, width) {
+  if (value.length >= width) return value;
+  return value.padEnd(width, " ");
+}
+function syncPlanMarkdown(app, planIds) {
+  if (!planIds.length) return;
+  const unique = Array.from(new Set(planIds));
+  const active = app.getActivePlan();
+  const activeId = active?.plan_id;
+  const activeUpdated = active?.updated_at ?? null;
+  unique.forEach((planId) => {
+    let detail;
+    try {
+      detail = app.getPlanDetail(planId);
+    } catch (err) {
+      if (err instanceof AppError && err.kind === "NotFound") return;
+      throw err;
+    }
+    const isActive = activeId === planId;
+    const activatedAt = isActive ? activeUpdated : null;
+    const mdPath = resolvePlanMarkdownPath(planId);
+    ensureParentDir(mdPath);
+    const markdown = formatPlanMarkdown(isActive, activatedAt, detail.plan, detail.steps, detail.goals);
+    fs3.writeFileSync(mdPath, markdown, "utf8");
+  });
+}
+
+// src/lib/config.ts
+import fs4 from "fs";
+import path3 from "path";
+var DEFAULT_KEYWORDS = {
+  any: [],
+  all: [],
+  none: [],
+  matchCase: false
+};
+var DEFAULT_EVENT_RULE = {
+  enabled: false,
+  force: false,
+  keywords: DEFAULT_KEYWORDS
+};
+var DEFAULT_SESSION_ERROR_RULE = {
+  enabled: false,
+  force: true,
+  keywords: DEFAULT_KEYWORDS,
+  errorNames: [],
+  statusCodes: [],
+  retryableOnly: false
+};
+var DEFAULT_SESSION_RETRY_RULE = {
+  enabled: false,
+  force: false,
+  keywords: DEFAULT_KEYWORDS,
+  attemptAtLeast: 1
+};
+var DEFAULT_SEND_RETRY = {
+  enabled: true,
+  maxAttempts: 3,
+  delaysMs: [1500, 5e3, 15e3]
+};
+var DEFAULT_PLANPILOT_CONFIG = {
+  autoContinue: {
+    sendRetry: DEFAULT_SEND_RETRY,
+    onSessionError: DEFAULT_SESSION_ERROR_RULE,
+    onSessionRetry: DEFAULT_SESSION_RETRY_RULE,
+    onPermissionAsked: DEFAULT_EVENT_RULE,
+    onPermissionRejected: {
+      ...DEFAULT_EVENT_RULE,
+      force: true
+    },
+    onQuestionAsked: DEFAULT_EVENT_RULE,
+    onQuestionRejected: {
+      ...DEFAULT_EVENT_RULE,
+      force: true
+    }
+  },
+  runtime: {
+    paused: false
+  }
+};
+function resolvePlanpilotConfigPath() {
+  const override = process.env.OPENCODE_PLANPILOT_CONFIG;
+  if (override && override.trim()) {
+    const value = override.trim();
+    return path3.isAbsolute(value) ? value : path3.resolve(value);
+  }
+  return path3.join(resolvePlanpilotDir(), "config.json");
+}
+function cloneDefaultConfig() {
+  return {
+    autoContinue: {
+      sendRetry: {
+        enabled: DEFAULT_PLANPILOT_CONFIG.autoContinue.sendRetry.enabled,
+        maxAttempts: DEFAULT_PLANPILOT_CONFIG.autoContinue.sendRetry.maxAttempts,
+        delaysMs: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.sendRetry.delaysMs]
+      },
+      onSessionError: {
+        enabled: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.enabled,
+        force: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.force,
+        keywords: {
+          any: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.keywords.any],
+          all: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.keywords.all],
+          none: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.keywords.none],
+          matchCase: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.keywords.matchCase
+        },
+        errorNames: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.errorNames],
+        statusCodes: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.statusCodes],
+        retryableOnly: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError.retryableOnly
+      },
+      onSessionRetry: {
+        enabled: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry.enabled,
+        force: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry.force,
+        keywords: {
+          any: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry.keywords.any],
+          all: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry.keywords.all],
+          none: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry.keywords.none],
+          matchCase: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry.keywords.matchCase
+        },
+        attemptAtLeast: DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry.attemptAtLeast
+      },
+      onPermissionAsked: {
+        enabled: DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionAsked.enabled,
+        force: DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionAsked.force,
+        keywords: {
+          any: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionAsked.keywords.any],
+          all: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionAsked.keywords.all],
+          none: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionAsked.keywords.none],
+          matchCase: DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionAsked.keywords.matchCase
+        }
+      },
+      onPermissionRejected: {
+        enabled: DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionRejected.enabled,
+        force: DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionRejected.force,
+        keywords: {
+          any: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionRejected.keywords.any],
+          all: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionRejected.keywords.all],
+          none: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionRejected.keywords.none],
+          matchCase: DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionRejected.keywords.matchCase
+        }
+      },
+      onQuestionAsked: {
+        enabled: DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionAsked.enabled,
+        force: DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionAsked.force,
+        keywords: {
+          any: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionAsked.keywords.any],
+          all: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionAsked.keywords.all],
+          none: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionAsked.keywords.none],
+          matchCase: DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionAsked.keywords.matchCase
+        }
+      },
+      onQuestionRejected: {
+        enabled: DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionRejected.enabled,
+        force: DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionRejected.force,
+        keywords: {
+          any: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionRejected.keywords.any],
+          all: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionRejected.keywords.all],
+          none: [...DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionRejected.keywords.none],
+          matchCase: DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionRejected.keywords.matchCase
+        }
+      }
+    },
+    runtime: {
+      paused: DEFAULT_PLANPILOT_CONFIG.runtime.paused
+    }
+  };
+}
+function parseBoolean(value, fallback) {
+  if (typeof value === "boolean") return value;
+  return fallback;
+}
+function parseStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  const parsed = value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
+  return Array.from(new Set(parsed));
+}
+function parseNumberArray(value) {
+  if (!Array.isArray(value)) return [];
+  const parsed = value.map((item) => typeof item === "number" ? item : Number.NaN).filter((item) => Number.isFinite(item)).map((item) => Math.trunc(item));
+  return Array.from(new Set(parsed));
+}
+function parsePositiveInt(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const parsed = Math.trunc(value);
+  return parsed > 0 ? parsed : fallback;
+}
+function parsePositiveNumberArray(value, fallback) {
+  if (!Array.isArray(value)) return fallback;
+  const parsed = value.map((item) => typeof item === "number" ? item : Number.NaN).filter((item) => Number.isFinite(item)).map((item) => Math.trunc(item)).filter((item) => item > 0);
+  if (!parsed.length) return fallback;
+  return Array.from(new Set(parsed));
+}
+function parseKeywordRule(value, fallback) {
+  return {
+    any: parseStringArray(value?.any),
+    all: parseStringArray(value?.all),
+    none: parseStringArray(value?.none),
+    matchCase: parseBoolean(value?.matchCase, fallback.matchCase)
+  };
+}
+function parseEventRule(value, fallback) {
+  return {
+    enabled: parseBoolean(value?.enabled, fallback.enabled),
+    force: parseBoolean(value?.force, fallback.force),
+    keywords: parseKeywordRule(value?.keywords, fallback.keywords)
+  };
+}
+function parseSessionErrorRule(value, fallback) {
+  const base = parseEventRule(value, fallback);
+  return {
+    ...base,
+    errorNames: parseStringArray(value?.errorNames),
+    statusCodes: parseNumberArray(value?.statusCodes),
+    retryableOnly: parseBoolean(value?.retryableOnly, fallback.retryableOnly)
+  };
+}
+function parseSessionRetryRule(value, fallback) {
+  const base = parseEventRule(value, fallback);
+  const rawAttempt = typeof value?.attemptAtLeast === "number" ? Math.trunc(value.attemptAtLeast) : fallback.attemptAtLeast;
+  return {
+    ...base,
+    attemptAtLeast: rawAttempt > 0 ? rawAttempt : fallback.attemptAtLeast
+  };
+}
+function parseSendRetryConfig(value, fallback) {
+  return {
+    enabled: parseBoolean(value?.enabled, fallback.enabled),
+    maxAttempts: parsePositiveInt(value?.maxAttempts, fallback.maxAttempts),
+    delaysMs: parsePositiveNumberArray(value?.delaysMs, fallback.delaysMs)
+  };
+}
+function parseConfig(raw) {
+  return {
+    autoContinue: {
+      sendRetry: parseSendRetryConfig(raw.autoContinue?.sendRetry, DEFAULT_PLANPILOT_CONFIG.autoContinue.sendRetry),
+      onSessionError: parseSessionErrorRule(
+        raw.autoContinue?.onSessionError,
+        DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionError
+      ),
+      onSessionRetry: parseSessionRetryRule(
+        raw.autoContinue?.onSessionRetry,
+        DEFAULT_PLANPILOT_CONFIG.autoContinue.onSessionRetry
+      ),
+      onPermissionAsked: parseEventRule(
+        raw.autoContinue?.onPermissionAsked,
+        DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionAsked
+      ),
+      onPermissionRejected: parseEventRule(
+        raw.autoContinue?.onPermissionRejected,
+        DEFAULT_PLANPILOT_CONFIG.autoContinue.onPermissionRejected
+      ),
+      onQuestionAsked: parseEventRule(
+        raw.autoContinue?.onQuestionAsked,
+        DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionAsked
+      ),
+      onQuestionRejected: parseEventRule(
+        raw.autoContinue?.onQuestionRejected,
+        DEFAULT_PLANPILOT_CONFIG.autoContinue.onQuestionRejected
+      )
+    },
+    runtime: {
+      paused: parseBoolean(raw.runtime?.paused, DEFAULT_PLANPILOT_CONFIG.runtime.paused)
+    }
+  };
+}
+function normalizePlanpilotConfig(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return cloneDefaultConfig();
+  }
+  return parseConfig(raw);
+}
+function loadPlanpilotConfig() {
+  const filePath = resolvePlanpilotConfigPath();
+  try {
+    if (!fs4.existsSync(filePath)) {
+      return {
+        path: filePath,
+        loadedFromFile: false,
+        config: cloneDefaultConfig()
+      };
+    }
+    const text = fs4.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(text);
+    return {
+      path: filePath,
+      loadedFromFile: true,
+      config: normalizePlanpilotConfig(parsed)
+    };
+  } catch (error) {
+    const loadError = error instanceof Error ? error.message : String(error);
+    return {
+      path: filePath,
+      loadedFromFile: false,
+      config: cloneDefaultConfig(),
+      loadError
+    };
+  }
+}
+function matchesKeywords(text, rule) {
+  const source = rule.matchCase ? text : text.toLowerCase();
+  const normalize = (value) => rule.matchCase ? value : value.toLowerCase();
+  const any = rule.any.map(normalize);
+  const all = rule.all.map(normalize);
+  const none = rule.none.map(normalize);
+  if (any.length > 0 && !any.some((term) => source.includes(term))) {
+    return false;
+  }
+  if (!all.every((term) => source.includes(term))) {
+    return false;
+  }
+  if (none.some((term) => source.includes(term))) {
+    return false;
+  }
+  return true;
+}
+
+// src/index.ts
+var PlanpilotPlugin = async (ctx) => {
+  const IDLE_DEBOUNCE_MS = 1e3;
+  const RECENT_SEND_DEDUPE_MS = 1500;
+  const TRIGGER_TTL_MS = 10 * 60 * 1e3;
+  const inFlight = /* @__PURE__ */ new Set();
+  const skipNextAuto = /* @__PURE__ */ new Set();
+  const lastIdleAt = /* @__PURE__ */ new Map();
+  const pendingTrigger = /* @__PURE__ */ new Map();
+  const recentSends = /* @__PURE__ */ new Map();
+  const sendRetryTimers = /* @__PURE__ */ new Map();
+  const sendRetryState = /* @__PURE__ */ new Map();
+  const manualStop = /* @__PURE__ */ new Map();
+  const waitTimers = /* @__PURE__ */ new Map();
+  const permissionAsked = /* @__PURE__ */ new Map();
+  const questionAsked = /* @__PURE__ */ new Map();
+  const runSeq = /* @__PURE__ */ new Map();
+  const loadedConfig = loadPlanpilotConfig();
+  const autoConfig = loadedConfig.config.autoContinue;
+  const clearWaitTimer = (sessionID) => {
+    const existing = waitTimers.get(sessionID);
+    if (existing) {
+      clearTimeout(existing);
+      waitTimers.delete(sessionID);
+    }
+  };
+  const log2 = async (level, message, extra) => {
+    try {
+      await ctx.client.app.log({
+        body: {
+          service: "opencode-planpilot",
+          level,
+          message,
+          extra
+        }
+      });
+    } catch {
+    }
+  };
+  const logDebug = async (message, extra) => {
+    await log2("debug", message, extra);
+  };
+  const clearSendRetryTimer = (sessionID) => {
+    const timer = sendRetryTimers.get(sessionID);
+    if (timer) {
+      clearTimeout(timer);
+      sendRetryTimers.delete(sessionID);
+    }
+  };
+  const clearSendRetry = (sessionID) => {
+    clearSendRetryTimer(sessionID);
+    sendRetryState.delete(sessionID);
+  };
+  const clearManualStop = async (sessionID, source) => {
+    if (!manualStop.has(sessionID)) return;
+    manualStop.delete(sessionID);
+    await logDebug("manual-stop guard cleared", { sessionID, source });
+  };
+  const setManualStop = async (sessionID, reason, source) => {
+    manualStop.set(sessionID, {
+      at: Date.now(),
+      reason
+    });
+    pendingTrigger.delete(sessionID);
+    clearSendRetry(sessionID);
+    await log2("info", "manual-stop guard armed", {
+      sessionID,
+      source,
+      reason
+    });
+  };
+  const stringifyError = (error) => {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "string") return error;
+    return String(error);
+  };
+  const isManualStopError = (error) => {
+    const text = stringifyError(error).toLowerCase();
+    return text.includes("aborted") || text.includes("cancel") || text.includes("canceled");
+  };
+  const buildRetryDetail = (baseDetail, attempt, max, message) => toSummary([
+    baseDetail,
+    `send-retry=${attempt}/${max}`,
+    message ? `error=${message}` : void 0
+  ]);
+  const scheduleSendRetry = async (input) => {
+    const cfg = autoConfig.sendRetry;
+    if (!cfg.enabled) return;
+    const blocked = manualStop.get(input.sessionID);
+    if (blocked) {
+      await logDebug("send retry skipped: manual-stop guard active", {
+        sessionID: input.sessionID,
+        source: input.source,
+        reason: blocked.reason
+      });
+      return;
+    }
+    const text = stringifyError(input.error);
+    if (isManualStopError(input.error)) {
+      await logDebug("send retry skipped: manual-stop style error", {
+        sessionID: input.sessionID,
+        source: input.source,
+        error: text
+      });
+      return;
+    }
+    const previous = sendRetryState.get(input.sessionID);
+    const attempt = previous && previous.signature === input.signature ? previous.attempt + 1 : 1;
+    if (attempt > cfg.maxAttempts) {
+      clearSendRetry(input.sessionID);
+      await log2("warn", "send retry exhausted", {
+        sessionID: input.sessionID,
+        source: input.source,
+        signature: input.signature,
+        maxAttempts: cfg.maxAttempts,
+        error: text
+      });
+      return;
+    }
+    sendRetryState.set(input.sessionID, {
+      signature: input.signature,
+      attempt
+    });
+    clearSendRetryTimer(input.sessionID);
+    const index = Math.min(Math.max(attempt - 1, 0), cfg.delaysMs.length - 1);
+    const delayMs = cfg.delaysMs[index];
+    const retryDetail = buildRetryDetail(input.detail, attempt, cfg.maxAttempts, text);
+    const timer = setTimeout(() => {
+      sendRetryTimers.delete(input.sessionID);
+      queueTrigger(input.sessionID, {
+        source: `${input.source}.send_retry`,
+        force: input.force,
+        detail: retryDetail
+      }).catch((err) => {
+        void log2("warn", "send retry trigger failed", {
+          sessionID: input.sessionID,
+          source: input.source,
+          error: stringifyError(err)
+        });
+      });
+    }, delayMs);
+    sendRetryTimers.set(input.sessionID, timer);
+    await log2("info", "send retry scheduled", {
+      sessionID: input.sessionID,
+      source: input.source,
+      signature: input.signature,
+      attempt,
+      maxAttempts: cfg.maxAttempts,
+      delayMs,
+      error: text
+    });
+  };
+  const nextRun = (sessionID) => {
+    const next = (runSeq.get(sessionID) ?? 0) + 1;
+    runSeq.set(sessionID, next);
+    return next;
+  };
+  const loadRecentMessages = async (sessionID, limit = 200) => {
+    const response = await ctx.client.session.messages({
+      path: { id: sessionID },
+      query: { limit }
+    });
+    const data = response.data ?? response;
+    if (!Array.isArray(data)) return [];
+    return data;
+  };
+  const findLastMessage = (messages, predicate) => {
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+      const message = messages[idx];
+      if (predicate(message)) return message;
+    }
+    return void 0;
+  };
+  const findLastMessageByRole = (messages, role) => findLastMessage(messages, (message) => message?.info?.role === role);
+  const resolveAutoContext = async (sessionID) => {
+    const messages = await loadRecentMessages(sessionID);
+    if (!messages.length) return null;
+    const sortedMessages = [...messages].sort((left, right) => {
+      const leftTime = left?.info?.time?.created ?? 0;
+      const rightTime = right?.info?.time?.created ?? 0;
+      return leftTime - rightTime;
+    });
+    const lastUser = findLastMessage(sortedMessages, (message) => message?.info?.role === "user");
+    if (!lastUser) return { missingUser: true };
+    const lastAssistant = findLastMessageByRole(sortedMessages, "assistant");
+    const error = lastAssistant?.info?.error;
+    const aborted = typeof error === "object" && error?.name === "MessageAbortedError";
+    const finish = lastAssistant?.info?.finish;
+    const ready = !lastAssistant || typeof finish === "string" && finish !== "tool-calls" && finish !== "unknown";
+    const model = lastUser?.info?.model ?? (lastUser?.info?.providerID && lastUser?.info?.modelID ? { providerID: lastUser.info.providerID, modelID: lastUser.info.modelID } : lastAssistant?.info?.providerID && lastAssistant?.info?.modelID ? { providerID: lastAssistant.info.providerID, modelID: lastAssistant.info.modelID } : void 0);
+    return {
+      agent: lastUser?.info?.agent ?? lastAssistant?.info?.agent,
+      model,
+      variant: lastUser?.info?.variant,
+      aborted,
+      ready,
+      missingUser: false,
+      assistantFinish: finish,
+      assistantErrorName: typeof error === "object" && error ? error.name : void 0,
+      assistantErrorMessage: typeof error === "object" && error && typeof error.data?.message === "string" ? error.data.message : void 0,
+      assistantErrorStatusCode: typeof error === "object" && error && typeof error.data?.statusCode === "number" && Number.isFinite(error.data.statusCode) ? Math.trunc(error.data.statusCode) : void 0,
+      assistantErrorRetryable: typeof error === "object" && error && typeof error.data?.isRetryable === "boolean" ? error.data.isRetryable : void 0
+    };
+  };
+  const toSummary = (parts) => parts.filter((part) => typeof part === "string" && part.trim().length > 0).join(" ").trim();
+  const toStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [];
+  const summarizePermissionEvent = (properties) => {
+    const permission = typeof properties?.permission === "string" ? properties.permission.trim() : "";
+    const patterns = toStringArray(properties?.patterns);
+    return toSummary([permission, patterns.length ? `patterns=${patterns.join(",")}` : void 0]);
+  };
+  const summarizeQuestionEvent = (properties) => {
+    const questions = Array.isArray(properties?.questions) ? properties.questions : [];
+    const pieces = questions.map(
+      (item) => toSummary([
+        typeof item?.header === "string" ? item.header.trim() : void 0,
+        typeof item?.question === "string" ? item.question.trim() : void 0
+      ])
+    ).filter(Boolean);
+    return pieces.join(" | ");
+  };
+  const shouldTriggerEventRule = (rule, text) => {
+    if (!rule.enabled) return false;
+    return matchesKeywords(text, rule.keywords);
+  };
+  const shouldTriggerSessionError = (rule, error) => {
+    if (!rule.enabled) return { matched: false, detail: "" };
+    if (!error || typeof error !== "object") return { matched: false, detail: "" };
+    const name = typeof error.name === "string" ? error.name : "";
+    const message = typeof error.data?.message === "string" ? error.data.message : "";
+    const statusCode = typeof error.data?.statusCode === "number" && Number.isFinite(error.data.statusCode) ? Math.trunc(error.data.statusCode) : void 0;
+    const retryable = typeof error.data?.isRetryable === "boolean" ? error.data.isRetryable : void 0;
+    if (rule.errorNames.length > 0 && !rule.errorNames.includes(name)) {
+      return { matched: false, detail: "" };
+    }
+    if (rule.statusCodes.length > 0) {
+      if (statusCode === void 0 || !rule.statusCodes.includes(statusCode)) {
+        return { matched: false, detail: "" };
+      }
+    }
+    if (rule.retryableOnly && retryable !== true) {
+      return { matched: false, detail: "" };
+    }
+    const detail = toSummary([
+      name ? `error=${name}` : void 0,
+      statusCode !== void 0 ? `status=${statusCode}` : void 0,
+      retryable !== void 0 ? `retryable=${retryable}` : void 0,
+      message
+    ]);
+    if (!matchesKeywords(detail, rule.keywords)) {
+      return { matched: false, detail };
+    }
+    return { matched: true, detail };
+  };
+  const shouldTriggerSessionRetry = (rule, status) => {
+    if (!rule.enabled) return { matched: false, detail: "" };
+    if (!status || typeof status !== "object") return { matched: false, detail: "" };
+    if (status.type !== "retry") return { matched: false, detail: "" };
+    const attempt = typeof status.attempt === "number" && Number.isFinite(status.attempt) ? Math.trunc(status.attempt) : 0;
+    const message = typeof status.message === "string" ? status.message : "";
+    const next = typeof status.next === "number" && Number.isFinite(status.next) ? Math.trunc(status.next) : void 0;
+    if (attempt < rule.attemptAtLeast) {
+      return { matched: false, detail: "" };
+    }
+    const detail = toSummary([
+      `attempt=${attempt}`,
+      next !== void 0 ? `next=${next}` : void 0,
+      message
+    ]);
+    if (!matchesKeywords(detail, rule.keywords)) {
+      return { matched: false, detail };
+    }
+    return { matched: true, detail };
+  };
+  const readTrigger = (sessionID) => {
+    const current = pendingTrigger.get(sessionID);
+    if (!current) return void 0;
+    if (Date.now() - current.at > TRIGGER_TTL_MS) {
+      pendingTrigger.delete(sessionID);
+      return void 0;
+    }
+    return current;
+  };
+  const queueTrigger = async (sessionID, trigger) => {
+    if (manualStop.has(sessionID)) {
+      await logDebug("auto-continue trigger skipped: manual-stop guard active", {
+        sessionID,
+        source: trigger.source
+      });
+      return;
+    }
+    pendingTrigger.set(sessionID, {
+      ...trigger,
+      at: Date.now()
+    });
+    await logDebug("auto-continue trigger queued", {
+      sessionID,
+      source: trigger.source,
+      force: trigger.force,
+      detail: trigger.detail
+    });
+    await handleSessionIdle(sessionID, trigger.source);
+  };
+  const handleSessionIdle = async (sessionID, source) => {
+    const now = Date.now();
+    const run = nextRun(sessionID);
+    const trigger = readTrigger(sessionID);
+    const force = trigger?.force === true;
+    const idleSource = source === "session.idle" || source === "session.status";
+    if (inFlight.has(sessionID)) {
+      await logDebug("auto-continue skipped: already in-flight", { sessionID, source, run, trigger: trigger?.source });
+      return;
+    }
+    const stopped = manualStop.get(sessionID);
+    if (stopped) {
+      pendingTrigger.delete(sessionID);
+      await logDebug("auto-continue skipped: manual-stop guard active", {
+        sessionID,
+        source,
+        run,
+        stopAt: stopped.at,
+        stopReason: stopped.reason
+      });
+      return;
+    }
+    inFlight.add(sessionID);
+    try {
+      if (skipNextAuto.has(sessionID)) {
+        skipNextAuto.delete(sessionID);
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue skipped: skipNextAuto", { sessionID, source, run, trigger: trigger?.source });
+        return;
+      }
+      if (idleSource && !trigger) {
+        const lastIdle = lastIdleAt.get(sessionID);
+        if (lastIdle && now - lastIdle < IDLE_DEBOUNCE_MS) {
+          await logDebug("auto-continue skipped: idle debounce", {
+            sessionID,
+            source,
+            run,
+            lastIdle,
+            now,
+            deltaMs: now - lastIdle
+          });
+          return;
+        }
+      }
+      if (idleSource) {
+        lastIdleAt.set(sessionID, now);
+      }
+      const app = new PlanpilotApp(openDatabase(), sessionID);
+      const active = app.getActivePlan();
+      if (!active) {
+        clearWaitTimer(sessionID);
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue skipped: no active plan", { sessionID, source, run, trigger: trigger?.source });
+        return;
+      }
+      const next = app.nextStep(active.plan_id);
+      if (!next) {
+        clearWaitTimer(sessionID);
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue skipped: no pending step", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          trigger: trigger?.source
+        });
+        return;
+      }
+      if (next.executor !== "ai") {
+        clearWaitTimer(sessionID);
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue skipped: next executor is not ai", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          stepId: next.id,
+          executor: next.executor,
+          trigger: trigger?.source
+        });
+        return;
+      }
+      const wait = parseWaitFromComment(next.comment);
+      if (wait && wait.until > now) {
+        clearWaitTimer(sessionID);
+        await log2("info", "auto-continue delayed by step wait", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          stepId: next.id,
+          until: wait.until,
+          reason: wait.reason,
+          trigger: trigger?.source
+        });
+        const msUntil = Math.max(0, wait.until - now);
+        const timer = setTimeout(() => {
+          waitTimers.delete(sessionID);
+          handleSessionIdle(sessionID, "wait_timer").catch((err) => {
+            void log2("warn", "auto-continue retry failed", {
+              sessionID,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          });
+        }, msUntil);
+        waitTimers.set(sessionID, timer);
+        return;
+      }
+      if (!wait) {
+        clearWaitTimer(sessionID);
+      }
+      const goals = app.goalsForStep(next.id);
+      const detail = formatStepDetail(next, goals);
+      if (!detail.trim()) {
+        pendingTrigger.delete(sessionID);
+        await log2("warn", "auto-continue stopped: empty step detail", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          stepId: next.id,
+          trigger: trigger?.source
+        });
+        return;
+      }
+      const signature = `${active.plan_id}:${next.id}`;
+      const retryState = sendRetryState.get(sessionID);
+      if (retryState && retryState.signature !== signature) {
+        clearSendRetry(sessionID);
+      }
+      const recent = recentSends.get(sessionID);
+      if (recent && recent.signature === signature && now - recent.at < RECENT_SEND_DEDUPE_MS) {
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue skipped: duplicate send window", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          stepId: next.id,
+          trigger: trigger?.source,
+          deltaMs: now - recent.at
+        });
+        return;
+      }
+      const autoContext = await resolveAutoContext(sessionID);
+      if (autoContext?.missingUser) {
+        pendingTrigger.delete(sessionID);
+        await log2("warn", "auto-continue stopped: missing user context", { sessionID, source, run, trigger: trigger?.source });
+        return;
+      }
+      if (!autoContext) {
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue stopped: missing autoContext (no recent messages?)", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          stepId: next.id,
+          trigger: trigger?.source
+        });
+        return;
+      }
+      if (autoContext.aborted && !force) {
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue skipped: last assistant aborted", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          stepId: next.id,
+          assistantErrorName: autoContext.assistantErrorName,
+          assistantErrorMessage: autoContext.assistantErrorMessage,
+          assistantFinish: autoContext.assistantFinish,
+          trigger: trigger?.source
+        });
+        return;
+      }
+      if (autoContext.ready === false && !force) {
+        pendingTrigger.delete(sessionID);
+        await logDebug("auto-continue skipped: last assistant not ready", {
+          sessionID,
+          source,
+          run,
+          planId: active.plan_id,
+          stepId: next.id,
+          assistantFinish: autoContext.assistantFinish,
+          assistantErrorName: autoContext.assistantErrorName,
+          assistantErrorMessage: autoContext.assistantErrorMessage,
+          trigger: trigger?.source
+        });
+        return;
+      }
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const message = formatPlanpilotAutoContinueMessage({
+        timestamp,
+        stepDetail: detail,
+        triggerDetail: trigger?.detail
+      });
+      const promptBody = {
+        agent: autoContext.agent ?? void 0,
+        model: autoContext.model ?? void 0,
+        parts: [{ type: "text", text: message }]
+      };
+      if (autoContext.variant) {
+        promptBody.variant = autoContext.variant;
+      }
+      await logDebug("auto-continue sending prompt_async", {
+        sessionID,
+        source,
+        run,
+        planId: active.plan_id,
+        stepId: next.id,
+        trigger: trigger?.source,
+        force,
+        agent: promptBody.agent,
+        model: promptBody.model,
+        variant: promptBody.variant,
+        messageChars: message.length
+      });
+      await ctx.client.session.promptAsync({
+        path: { id: sessionID },
+        body: promptBody,
+        // OpenCode server routes requests to the correct instance (project) using this header.
+        // Without it, the server falls back to process.cwd(), which breaks when OpenCode is
+        // managed by opencode-studio (cwd != active project directory).
+        headers: ctx.directory ? { "x-opencode-directory": ctx.directory } : void 0
+      }).catch(async (err) => {
+        await scheduleSendRetry({
+          sessionID,
+          signature,
+          source,
+          force,
+          detail: trigger?.detail,
+          error: err
+        });
+        throw err;
+      });
+      recentSends.set(sessionID, {
+        signature,
+        at: Date.now()
+      });
+      clearSendRetry(sessionID);
+      pendingTrigger.delete(sessionID);
+      await log2("info", "auto-continue prompt_async accepted", {
+        sessionID,
+        source,
+        run,
+        planId: active.plan_id,
+        stepId: next.id,
+        trigger: trigger?.source,
+        force
+      });
+    } catch (err) {
+      await log2("warn", "failed to auto-continue plan", {
+        sessionID,
+        source,
+        error: err instanceof Error ? err.message : String(err),
+        stack: err instanceof Error ? err.stack : void 0
+      });
+    } finally {
+      inFlight.delete(sessionID);
+    }
+  };
+  if (loadedConfig.loadError) {
+    await log2("warn", "failed to load planpilot config, falling back to defaults", {
+      path: loadedConfig.path,
+      error: loadedConfig.loadError
+    });
+  }
+  await log2("info", "planpilot plugin initialized", {
+    directory: ctx.directory,
+    worktree: ctx.worktree,
+    configPath: loadedConfig.path,
+    configLoadedFromFile: loadedConfig.loadedFromFile
+  });
+  return {
+    "experimental.chat.system.transform": async (_input, output) => {
+      output.system.push(PLANPILOT_SYSTEM_INJECTION);
+    },
+    tool: {
+      planpilot: tool({
+        description: PLANPILOT_TOOL_DESCRIPTION,
+        args: {
+          argv: tool.schema.array(tool.schema.string()).min(1)
+        },
+        async execute(args, toolCtx) {
+          const argv = Array.isArray(args.argv) ? args.argv : [];
+          if (!argv.length) {
+            return formatCommandError(invalidInput("missing argv"));
+          }
+          if (containsForbiddenFlags(argv)) {
+            return formatCommandError(invalidInput("argv cannot include --cwd or --session-id"));
+          }
+          const cwd = (ctx.directory ?? "").trim();
+          if (!cwd) {
+            return formatCommandError(invalidInput("cwd is required"));
+          }
+          const output = [];
+          const io = {
+            log: (...parts) => output.push(parts.map(String).join(" "))
+          };
+          try {
+            await runCommand(argv, { sessionId: toolCtx.sessionID, cwd }, io);
+          } catch (err) {
+            return formatCommandError(err);
+          }
+          return output.join("\n").trimEnd();
+        }
+      })
+    },
+    "experimental.session.compacting": async ({ sessionID }, output) => {
+      skipNextAuto.add(sessionID);
+      lastIdleAt.set(sessionID, Date.now());
+      await logDebug("compaction hook: skip next auto-continue", { sessionID });
+      output.context.push(PLANPILOT_TOOL_DESCRIPTION);
+    },
+    event: async ({ event }) => {
+      const evt = event;
+      if (evt.type === "message.updated") {
+        const info = evt.properties?.info;
+        const sessionID = typeof info?.sessionID === "string" ? info.sessionID : "";
+        if (!sessionID) return;
+        if (info.role === "user") {
+          pendingTrigger.delete(sessionID);
+          clearSendRetry(sessionID);
+          await clearManualStop(sessionID, "message.updated.user");
+          return;
+        }
+        if (info.role === "assistant" && info.error?.name === "MessageAbortedError") {
+          await setManualStop(sessionID, "assistant message aborted", "message.updated.assistant");
+        }
+        return;
+      }
+      if (evt.type === "session.idle") {
+        await handleSessionIdle(evt.properties.sessionID, "session.idle");
+        return;
+      }
+      if (evt.type === "session.status") {
+        if (evt.properties.status.type === "idle") {
+          await handleSessionIdle(evt.properties.sessionID, "session.status");
+          return;
+        }
+        const retryResult = shouldTriggerSessionRetry(autoConfig.onSessionRetry, evt.properties.status);
+        if (!retryResult.matched) return;
+        await queueTrigger(evt.properties.sessionID, {
+          source: "session.status.retry",
+          force: autoConfig.onSessionRetry.force,
+          detail: retryResult.detail || "session status retry"
+        });
+        return;
+      }
+      if (evt.type === "session.error") {
+        const sessionID = typeof evt.properties?.sessionID === "string" ? evt.properties.sessionID : "";
+        if (!sessionID) return;
+        if (evt.properties?.error?.name === "MessageAbortedError") {
+          await setManualStop(sessionID, "session aborted", "session.error");
+          return;
+        }
+        const errorResult = shouldTriggerSessionError(autoConfig.onSessionError, evt.properties?.error);
+        if (!errorResult.matched) return;
+        await queueTrigger(sessionID, {
+          source: "session.error",
+          force: autoConfig.onSessionError.force,
+          detail: errorResult.detail || "session error"
+        });
+        return;
+      }
+      if (evt.type === "permission.asked") {
+        const sessionID = typeof evt.properties?.sessionID === "string" ? evt.properties.sessionID : "";
+        if (!sessionID) return;
+        const requestID = typeof evt.properties?.id === "string" ? evt.properties.id : "";
+        const summary = summarizePermissionEvent(evt.properties);
+        if (requestID) {
+          permissionAsked.set(requestID, {
+            sessionID,
+            summary
+          });
+        }
+        if (!shouldTriggerEventRule(autoConfig.onPermissionAsked, summary || "permission asked")) return;
+        await queueTrigger(sessionID, {
+          source: "permission.asked",
+          force: autoConfig.onPermissionAsked.force,
+          detail: summary || "permission asked"
+        });
+        return;
+      }
+      if (evt.type === "permission.replied") {
+        const sessionID = typeof evt.properties?.sessionID === "string" ? evt.properties.sessionID : "";
+        if (!sessionID) return;
+        const requestID = typeof evt.properties?.requestID === "string" ? evt.properties.requestID : typeof evt.properties?.permissionID === "string" ? evt.properties.permissionID : "";
+        const reply = typeof evt.properties?.reply === "string" ? evt.properties.reply : typeof evt.properties?.response === "string" ? evt.properties.response : "";
+        const asked = requestID ? permissionAsked.get(requestID) : void 0;
+        if (requestID) {
+          permissionAsked.delete(requestID);
+        }
+        if (reply !== "reject") return;
+        const summary = toSummary([
+          asked?.summary,
+          requestID ? `request=${requestID}` : void 0,
+          "reply=reject"
+        ]);
+        if (!shouldTriggerEventRule(autoConfig.onPermissionRejected, summary || "permission rejected")) return;
+        await queueTrigger(sessionID, {
+          source: "permission.replied.reject",
+          force: autoConfig.onPermissionRejected.force,
+          detail: summary || "permission rejected"
+        });
+        return;
+      }
+      if (evt.type === "question.asked") {
+        const sessionID = typeof evt.properties?.sessionID === "string" ? evt.properties.sessionID : "";
+        if (!sessionID) return;
+        const requestID = typeof evt.properties?.id === "string" ? evt.properties.id : "";
+        const summary = summarizeQuestionEvent(evt.properties);
+        if (requestID) {
+          questionAsked.set(requestID, {
+            sessionID,
+            summary
+          });
+        }
+        if (!shouldTriggerEventRule(autoConfig.onQuestionAsked, summary || "question asked")) return;
+        await queueTrigger(sessionID, {
+          source: "question.asked",
+          force: autoConfig.onQuestionAsked.force,
+          detail: summary || "question asked"
+        });
+        return;
+      }
+      if (evt.type === "question.replied") {
+        const requestID = typeof evt.properties?.requestID === "string" ? evt.properties.requestID : "";
+        if (!requestID) return;
+        questionAsked.delete(requestID);
+        return;
+      }
+      if (evt.type === "question.rejected") {
+        const sessionID = typeof evt.properties?.sessionID === "string" ? evt.properties.sessionID : "";
+        if (!sessionID) return;
+        const requestID = typeof evt.properties?.requestID === "string" ? evt.properties.requestID : "";
+        const asked = requestID ? questionAsked.get(requestID) : void 0;
+        if (requestID) {
+          questionAsked.delete(requestID);
+        }
+        const summary = toSummary([
+          asked?.summary,
+          requestID ? `request=${requestID}` : void 0,
+          "question=rejected"
+        ]);
+        if (!shouldTriggerEventRule(autoConfig.onQuestionRejected, summary || "question rejected")) return;
+        await queueTrigger(sessionID, {
+          source: "question.rejected",
+          force: autoConfig.onQuestionRejected.force,
+          detail: summary || "question rejected"
+        });
+      }
+    }
+  };
+};
+var src_default = PlanpilotPlugin;
+function containsForbiddenFlags(argv) {
+  return argv.some((token) => {
+    if (token === "--cwd" || token === "--session-id") return true;
+    if (token.startsWith("--cwd=") || token.startsWith("--session-id=")) return true;
+    return false;
+  });
+}
+export {
+  PlanpilotPlugin,
+  src_default as default
+};
+//# sourceMappingURL=index.js.map