opencode-planpilot 0.2.3 → 0.2.4

package/dist/studio-bridge.js

@@ -0,0 +1,1985 @@
+// 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);
+}
+
+// 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;
+}
+
+// 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();
+}
+
+// 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/lib/config.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// 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 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/config.ts
+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 path2.isAbsolute(value) ? value : path2.resolve(value);
+  }
+  return path2.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 savePlanpilotConfig(config) {
+  const filePath = resolvePlanpilotConfigPath();
+  const normalized = normalizePlanpilotConfig(config);
+  const parentDir = path2.dirname(filePath);
+  fs2.mkdirSync(parentDir, { recursive: true });
+  fs2.writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}
+`, "utf8");
+  return {
+    path: filePath,
+    loadedFromFile: true,
+    config: normalized
+  };
+}
+function loadPlanpilotConfig() {
+  const filePath = resolvePlanpilotConfigPath();
+  try {
+    if (!fs2.existsSync(filePath)) {
+      return {
+        path: filePath,
+        loadedFromFile: false,
+        config: cloneDefaultConfig()
+      };
+    }
+    const text = fs2.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
+    };
+  }
+}
+
+// src/studio/bridge.ts
+var DEFAULT_SESSION_ID = "studio";
+var PLAN_UPDATE_ALLOWED = /* @__PURE__ */ new Set(["title", "content", "status", "comment"]);
+var STEP_UPDATE_ALLOWED = /* @__PURE__ */ new Set(["content", "status", "executor", "comment"]);
+var GOAL_UPDATE_ALLOWED = /* @__PURE__ */ new Set(["content", "status", "comment"]);
+async function main() {
+  const response = await runBridge();
+  process.stdout.write(JSON.stringify(response));
+}
+async function runBridge() {
+  try {
+    const raw = await readStdinOnce();
+    const request = parseRequest(raw);
+    const context = resolveRequestContext(request);
+    const data = dispatch(request.action, request.payload, context);
+    return ok(data);
+  } catch (error) {
+    return fail(error);
+  }
+}
+function parseRequest(raw) {
+  if (!raw.trim()) {
+    throw invalidInput("bridge request is empty");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw invalidInput(`bridge request is not valid JSON: ${message}`);
+  }
+  const root = asObject(parsed, "bridge request");
+  const action = expectString(root.action, "action");
+  return {
+    action,
+    payload: root.payload,
+    context: root.context,
+    plugin: root.plugin
+  };
+}
+function resolveRequestContext(request) {
+  const context = asObjectOptional(request.context);
+  const plugin = asObjectOptional(request.plugin);
+  const sessionId = readNonEmptyString(context?.sessionId) ?? readNonEmptyString(context?.sessionID) ?? DEFAULT_SESSION_ID;
+  const cwd = readNonEmptyString(context?.cwd) ?? readNonEmptyString(context?.directory) ?? readNonEmptyString(plugin?.rootPath) ?? void 0;
+  return { sessionId, cwd };
+}
+function createApp(context) {
+  return new PlanpilotApp(openDatabase(), context.sessionId, context.cwd);
+}
+function dispatch(action, payload, context) {
+  const handler = ACTIONS[action];
+  if (!handler) {
+    throw invalidInput(`unknown action: ${action}`);
+  }
+  return handler(payload, context);
+}
+var ACTIONS = {
+  "runtime.snapshot": actionRuntimeSnapshot,
+  "runtime.next": actionRuntimeNext,
+  "runtime.pause": actionRuntimePause,
+  "runtime.resume": actionRuntimeResume,
+  "events.poll": actionEventsPoll,
+  "config.get": actionConfigGet,
+  "config.set": actionConfigSet,
+  "plan.list": actionPlanList,
+  "plan.get": actionPlanGet,
+  "plan.createTree": actionPlanAddTree,
+  "plan.addTree": actionPlanAddTree,
+  "plan.update": actionPlanUpdate,
+  "plan.done": actionPlanDone,
+  "plan.remove": actionPlanRemove,
+  "plan.activate": actionPlanActivate,
+  "plan.deactivate": actionPlanDeactivate,
+  "plan.active": actionPlanActive,
+  "step.list": actionStepList,
+  "step.get": actionStepGet,
+  "step.add": actionStepAdd,
+  "step.addTree": actionStepAddTree,
+  "step.update": actionStepUpdate,
+  "step.done": actionStepDone,
+  "step.remove": actionStepRemove,
+  "step.move": actionStepMove,
+  "step.wait": actionStepWait,
+  "goal.list": actionGoalList,
+  "goal.get": actionGoalGet,
+  "goal.add": actionGoalAdd,
+  "goal.update": actionGoalUpdate,
+  "goal.done": actionGoalDone,
+  "goal.remove": actionGoalRemove
+};
+function actionRuntimeSnapshot(_payload, context) {
+  const app = createApp(context);
+  return buildRuntimeSnapshot(app, loadPlanpilotConfig().config);
+}
+function actionRuntimeNext(_payload, context) {
+  const app = createApp(context);
+  const active = app.getActivePlan();
+  if (!active) {
+    return {
+      activePlan: null,
+      nextStep: null,
+      cursor: buildRuntimeCursor(app, loadPlanpilotConfig().config)
+    };
+  }
+  const nextStep = app.nextStep(active.plan_id);
+  return {
+    activePlan: active,
+    nextStep: nextStep ? serializeStepDetail(app.getStepDetail(nextStep.id)) : null,
+    cursor: buildRuntimeCursor(app, loadPlanpilotConfig().config)
+  };
+}
+function actionRuntimePause(_payload, context) {
+  const loaded = loadPlanpilotConfig();
+  const config = normalizePlanpilotConfig(loaded.config);
+  config.runtime.paused = true;
+  savePlanpilotConfig(config);
+  const app = createApp(context);
+  return buildRuntimeSnapshot(app, config);
+}
+function actionRuntimeResume(_payload, context) {
+  const loaded = loadPlanpilotConfig();
+  const config = normalizePlanpilotConfig(loaded.config);
+  config.runtime.paused = false;
+  savePlanpilotConfig(config);
+  const app = createApp(context);
+  return buildRuntimeSnapshot(app, config);
+}
+function actionEventsPoll(payload, context) {
+  const app = createApp(context);
+  const config = loadPlanpilotConfig().config;
+  const currentCursor = buildRuntimeCursor(app, config);
+  const input = asObjectOptional(payload);
+  const previousCursor = readNonEmptyString(input?.cursor) ?? "";
+  if (previousCursor === currentCursor) {
+    return {
+      cursor: currentCursor,
+      events: []
+    };
+  }
+  return {
+    cursor: currentCursor,
+    events: [
+      {
+        event: "planpilot.runtime.changed",
+        id: currentCursor,
+        data: buildRuntimeSnapshot(app, config)
+      }
+    ]
+  };
+}
+function actionConfigGet(_payload, _context) {
+  const loaded = loadPlanpilotConfig();
+  return loaded.config;
+}
+function actionConfigSet(payload, _context) {
+  const root = asObject(payload, "config.set payload");
+  const raw = "config" in root ? root.config : payload;
+  const normalized = normalizePlanpilotConfig(raw);
+  const saved = savePlanpilotConfig(normalized);
+  return {
+    path: saved.path,
+    config: saved.config
+  };
+}
+function actionPlanList(payload, context) {
+  const app = createApp(context);
+  const input = asObjectOptional(payload);
+  const order = parsePlanOrderOptional(input?.order);
+  const desc = readBoolean(input?.desc) ?? true;
+  const plans = app.listPlans(order, desc);
+  return plans;
+}
+function actionPlanGet(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "plan.get payload");
+  const id = expectInt(input.id, "id");
+  return serializePlanDetail(app.getPlanDetail(id));
+}
+function actionPlanAddTree(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "plan.createTree payload");
+  const title = expectString(input.title, "title");
+  const content = expectString(input.content, "content");
+  const stepsInput = expectArray(input.steps, "steps");
+  const steps = stepsInput.map((item, index) => {
+    const step = asObject(item, `steps[${index}]`);
+    return {
+      content: expectString(step.content, `steps[${index}].content`),
+      executor: parseExecutorOptional(step.executor) ?? "ai",
+      goals: readStringArray(step.goals)
+    };
+  });
+  const result = app.addPlanTree({ title, content }, steps);
+  return {
+    plan: result.plan,
+    stepCount: result.stepCount,
+    goalCount: result.goalCount,
+    detail: serializePlanDetail(app.getPlanDetail(result.plan.id))
+  };
+}
+function actionPlanUpdate(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "plan.update payload");
+  const id = expectInt(input.id, "id");
+  assertAllowedKeys(input, PLAN_UPDATE_ALLOWED, "plan.update");
+  const result = app.updatePlanWithActiveClear(id, {
+    title: readString(input.title),
+    content: readString(input.content),
+    status: parsePlanStatusOptional(input.status),
+    comment: readNullableString(input.comment)
+  });
+  return {
+    plan: result.plan,
+    cleared: result.cleared
+  };
+}
+function actionPlanDone(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "plan.done payload");
+  const id = expectInt(input.id, "id");
+  return app.updatePlanWithActiveClear(id, { status: "done" });
+}
+function actionPlanRemove(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "plan.remove payload");
+  const id = expectInt(input.id, "id");
+  app.deletePlan(id);
+  return { removed: id };
+}
+function actionPlanActivate(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "plan.activate payload");
+  const id = expectInt(input.id, "id");
+  const force = readBoolean(input.force) ?? false;
+  const plan = app.getPlan(id);
+  if (plan.status === "done") {
+    throw invalidInput("cannot activate plan; plan is done");
+  }
+  return app.setActivePlan(id, force);
+}
+function actionPlanDeactivate(_payload, context) {
+  const app = createApp(context);
+  const active = app.getActivePlan();
+  app.clearActivePlan();
+  return {
+    activePlan: active,
+    deactivated: true
+  };
+}
+function actionPlanActive(_payload, context) {
+  const app = createApp(context);
+  const active = app.getActivePlan();
+  if (!active) {
+    return { activePlan: null, detail: null };
+  }
+  return {
+    activePlan: active,
+    detail: serializePlanDetail(app.getPlanDetail(active.plan_id))
+  };
+}
+function actionStepList(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.list payload");
+  const planId = expectInt(input.planId, "planId");
+  const query = {
+    status: parseStepStatusOptional(input.status),
+    executor: parseExecutorOptional(input.executor),
+    limit: parseIntOptional(input.limit),
+    offset: parseIntOptional(input.offset),
+    order: parseStepOrderOptional(input.order),
+    desc: readBoolean(input.desc)
+  };
+  const steps = app.listStepsFiltered(planId, query);
+  return steps;
+}
+function actionStepGet(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.get payload");
+  const id = expectInt(input.id, "id");
+  return serializeStepDetail(app.getStepDetail(id));
+}
+function actionStepAdd(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.add payload");
+  const planId = expectInt(input.planId, "planId");
+  const contents = resolveContents(input, "content", "contents");
+  const executor = parseExecutorOptional(input.executor) ?? "ai";
+  const at = parseIntOptional(input.at);
+  const result = app.addStepsBatch(planId, contents, "todo", executor, at);
+  return {
+    steps: result.steps,
+    changes: result.changes
+  };
+}
+function actionStepAddTree(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.addTree payload");
+  const planId = expectInt(input.planId, "planId");
+  const content = expectString(input.content, "content");
+  const executor = parseExecutorOptional(input.executor) ?? "ai";
+  const goals = readStringArray(input.goals);
+  return app.addStepTree(planId, content, executor, goals);
+}
+function actionStepUpdate(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.update payload");
+  const id = expectInt(input.id, "id");
+  assertAllowedKeys(input, STEP_UPDATE_ALLOWED, "step.update");
+  return app.updateStep(id, {
+    content: readString(input.content),
+    status: parseStepStatusOptional(input.status),
+    executor: parseExecutorOptional(input.executor),
+    comment: readNullableString(input.comment)
+  });
+}
+function actionStepDone(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.done payload");
+  const id = expectInt(input.id, "id");
+  const allGoals = readBoolean(input.allGoals) ?? false;
+  return app.setStepDoneWithGoals(id, allGoals);
+}
+function actionStepRemove(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.remove payload");
+  const ids = resolveIds(input);
+  return app.deleteSteps(ids);
+}
+function actionStepMove(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.move payload");
+  const id = expectInt(input.id, "id");
+  const to = expectInt(input.to, "to");
+  return app.moveStep(id, to);
+}
+function actionStepWait(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "step.wait payload");
+  const id = expectInt(input.id, "id");
+  const clear = readBoolean(input.clear) ?? false;
+  if (clear) {
+    return app.clearStepWait(id);
+  }
+  const delayMs = expectInt(input.delayMs, "delayMs");
+  const reason = readString(input.reason);
+  return app.setStepWait(id, delayMs, reason);
+}
+function actionGoalList(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "goal.list payload");
+  const stepId = expectInt(input.stepId, "stepId");
+  const query = {
+    status: parseGoalStatusOptional(input.status),
+    limit: parseIntOptional(input.limit),
+    offset: parseIntOptional(input.offset)
+  };
+  return app.listGoalsFiltered(stepId, query);
+}
+function actionGoalGet(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "goal.get payload");
+  const id = expectInt(input.id, "id");
+  return app.getGoalDetail(id);
+}
+function actionGoalAdd(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "goal.add payload");
+  const stepId = expectInt(input.stepId, "stepId");
+  const contents = resolveContents(input, "content", "contents");
+  return app.addGoalsBatch(stepId, contents, "todo");
+}
+function actionGoalUpdate(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "goal.update payload");
+  const id = expectInt(input.id, "id");
+  assertAllowedKeys(input, GOAL_UPDATE_ALLOWED, "goal.update");
+  return app.updateGoal(id, {
+    content: readString(input.content),
+    status: parseGoalStatusOptional(input.status),
+    comment: readNullableString(input.comment)
+  });
+}
+function actionGoalDone(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "goal.done payload");
+  const ids = resolveIds(input);
+  if (ids.length === 1) {
+    return app.setGoalStatus(ids[0], "done");
+  }
+  return app.setGoalsStatus(ids, "done");
+}
+function actionGoalRemove(payload, context) {
+  const app = createApp(context);
+  const input = asObject(payload, "goal.remove payload");
+  const ids = resolveIds(input);
+  return app.deleteGoals(ids);
+}
+function resolveContents(input, contentKey, contentsKey) {
+  const content = readString(input[contentKey]);
+  const contents = readStringArray(input[contentsKey]);
+  const out = content ? [content, ...contents] : contents;
+  if (!out.length) {
+    throw invalidInput(`expected ${contentKey} or ${contentsKey}`);
+  }
+  return out;
+}
+function resolveIds(input) {
+  const fromSingle = parseIntOptional(input.id);
+  const fromMany = readIntArray(input.ids);
+  const ids = fromSingle !== void 0 ? [fromSingle, ...fromMany] : fromMany;
+  if (!ids.length) {
+    throw invalidInput("expected id or ids");
+  }
+  return Array.from(new Set(ids));
+}
+function parsePlanOrderOptional(value) {
+  const raw = readString(value);
+  if (!raw) return void 0;
+  if (raw === "id" || raw === "title" || raw === "created" || raw === "updated") return raw;
+  throw invalidInput(`invalid plan order '${raw}', expected id|title|created|updated`);
+}
+function parseStepOrderOptional(value) {
+  const raw = readString(value);
+  if (!raw) return void 0;
+  if (raw === "order" || raw === "id" || raw === "created" || raw === "updated") return raw;
+  throw invalidInput(`invalid step order '${raw}', expected order|id|created|updated`);
+}
+function parsePlanStatusOptional(value) {
+  const raw = readString(value);
+  if (!raw) return void 0;
+  if (raw === "todo" || raw === "done") return raw;
+  throw invalidInput(`invalid plan status '${raw}', expected todo|done`);
+}
+function parseStepStatusOptional(value) {
+  const raw = parsePlanStatusOptional(value);
+  return raw;
+}
+function parseGoalStatusOptional(value) {
+  const raw = parsePlanStatusOptional(value);
+  return raw;
+}
+function parseExecutorOptional(value) {
+  const raw = readString(value);
+  if (!raw) return void 0;
+  if (raw === "ai" || raw === "human") return raw;
+  throw invalidInput(`invalid executor '${raw}', expected ai|human`);
+}
+function assertAllowedKeys(input, allowed, action) {
+  for (const key of Object.keys(input)) {
+    if (key === "id") continue;
+    if (!allowed.has(key)) {
+      throw invalidInput(`${action} does not support '${key}'`);
+    }
+  }
+}
+function buildRuntimeSnapshot(app, config) {
+  const active = app.getActivePlan();
+  const next = active ? app.nextStep(active.plan_id) : null;
+  return {
+    paused: config.runtime.paused,
+    activePlan: active,
+    nextStep: next ? serializeStepDetail(app.getStepDetail(next.id)) : null,
+    cursor: buildRuntimeCursor(app, config)
+  };
+}
+function buildRuntimeCursor(app, config) {
+  const plans = app.listPlans("updated", true);
+  const latestPlanUpdated = plans.length ? plans[0].updated_at : 0;
+  const active = app.getActivePlan();
+  const activeUpdated = active?.updated_at ?? 0;
+  const activePlanId = active?.plan_id ?? 0;
+  const next = active ? app.nextStep(active.plan_id) : null;
+  const nextStepId = next?.id ?? 0;
+  const paused = config.runtime.paused ? 1 : 0;
+  return [paused, latestPlanUpdated, activeUpdated, activePlanId, nextStepId].join(":");
+}
+function serializePlanDetail(detail) {
+  const goals = detail.steps.map((step) => ({
+    stepId: step.id,
+    goals: detail.goals.get(step.id) ?? []
+  }));
+  return {
+    plan: detail.plan,
+    steps: detail.steps,
+    goals
+  };
+}
+function serializeStepDetail(detail) {
+  const wait = parseWaitFromComment(detail.step.comment);
+  return {
+    step: detail.step,
+    goals: detail.goals,
+    wait
+  };
+}
+function ok(data) {
+  return { ok: true, data };
+}
+function fail(error) {
+  if (error instanceof AppError) {
+    const code = error.kind === "InvalidInput" ? "invalid_input" : error.kind === "NotFound" ? "not_found" : error.kind === "Db" ? "db_error" : error.kind === "Io" ? "io_error" : "json_error";
+    return {
+      ok: false,
+      error: {
+        code,
+        message: error.toDisplayString(),
+        details: null
+      }
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    ok: false,
+    error: {
+      code: "internal_error",
+      message,
+      details: null
+    }
+  };
+}
+function asObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalidInput(`${label} must be an object`);
+  }
+  return value;
+}
+function asObjectOptional(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function expectString(value, label) {
+  const parsed = readString(value);
+  if (!parsed) {
+    throw invalidInput(`${label} is required`);
+  }
+  return parsed;
+}
+function readString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : void 0;
+}
+function readNullableString(value) {
+  if (value === null || value === void 0) return void 0;
+  return readString(value);
+}
+function readNonEmptyString(value) {
+  return readString(value);
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function expectInt(value, label) {
+  const parsed = parseIntOptional(value);
+  if (parsed === void 0) {
+    throw invalidInput(`${label} must be an integer`);
+  }
+  return parsed;
+}
+function parseIntOptional(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
+    return void 0;
+  }
+  return value;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    const text = readString(item);
+    if (text) out.push(text);
+  }
+  return out;
+}
+function readIntArray(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    const id = parseIntOptional(item);
+    if (id !== void 0) out.push(id);
+  }
+  return out;
+}
+function expectArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw invalidInput(`${label} must be an array`);
+  }
+  return value;
+}
+async function readStdinOnce() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+void main();
+//# sourceMappingURL=studio-bridge.js.map