codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/plan-item-service.js

@@ -0,0 +1,1223 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_item_service_exports = {};
+__export(plan_item_service_exports, {
+  PlanItemStructureError: () => PlanItemStructureError,
+  applyRecordedState: () => applyRecordedState,
+  assertValidParent: () => assertValidParent,
+  claimItem: () => claimItem,
+  createItem: () => createItem,
+  deleteItem: () => deleteItem,
+  dependencyLookup: () => dependencyLookup,
+  dependencyStateOf: () => dependencyStateOf,
+  getChildren: () => getChildren,
+  getEffectiveVisibility: () => getEffectiveVisibility,
+  getItem: () => getItem,
+  getNextItem: () => getNextItem,
+  listAllItems: () => listAllItems,
+  listItemSummaries: () => listItemSummaries,
+  listItemVersions: () => listItemVersions,
+  listItemsForExport: () => listItemsForExport,
+  moveItem: () => moveItem,
+  planWaits: () => planWaits,
+  resolveClaimPolicy: () => resolveClaimPolicy,
+  resolveClaimPolicyWithSource: () => resolveClaimPolicyWithSource,
+  resolveConstraints: () => resolveConstraints,
+  resolveConstraintsWithSource: () => resolveConstraintsWithSource,
+  resolveExecutionConfigWithSource: () => resolveExecutionConfigWithSource,
+  resolveSkills: () => resolveSkills,
+  resolveSkillsWithSource: () => resolveSkillsWithSource,
+  restoreItemVersion: () => restoreItemVersion,
+  setStateWriteListener: () => setStateWriteListener,
+  setStatusChangeListener: () => setStatusChangeListener,
+  updateItem: () => updateItem,
+  withoutStateRecords: () => withoutStateRecords
+});
+module.exports = __toCommonJS(plan_item_service_exports);
+var import_item_status = require("../../shared/lib/item-status");
+var import_node_crypto = require("node:crypto");
+var import_spec_proposal_withdraw = require("./spec-proposal-withdraw");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_agent_event_log = require("./agent-event-log");
+var import_skill_model = require("./skill-model");
+var import_plan_event_service = require("./plan-event-service");
+var import_criteria_service = require("./criteria-service");
+var import_plan_dependencies = require("./plan-dependencies");
+var _lazy___plan_file_service = __toESM(require("./plan-file-service"));
+const ITEM_COLUMNS = `uid, plan_uid, parent_uid, sort_order, kind,
+  title, body, template,
+  status, assignee, assignee_type, assignee_model,
+  progress_percent, blocked_reason,
+  scope_path, file_specs, symbol_specs, new_connections, removed_conns, dependencies,
+  skills, skills_mode, claim_policy, claim_policy_mode, execution_config, execution_config_mode,
+  constraints, constraints_mode, requires_approval,
+  author, author_type, created_at, updated_at, migrated_from,
+  visibility, visibility_override, assignee_session, workstream`;
+function rowToItem(r) {
+  return {
+    uid: r[0],
+    planUid: r[1],
+    parentUid: r[2] ?? null,
+    sortOrder: r[3],
+    kind: r[4],
+    title: r[5],
+    body: r[6] ?? "",
+    template: r[7] ?? null,
+    status: r[8] ?? null,
+    assignee: r[9] ?? null,
+    assigneeType: r[10] ?? null,
+    assigneeModel: r[11] ?? null,
+    progressPercent: r[12] ?? null,
+    blockedReason: r[13] ?? null,
+    scopePath: r[14] ?? null,
+    fileSpecs: parseJsonArray(r[15]),
+    symbolSpecs: parseJsonArray(r[16]),
+    newConnections: parseJsonArray(r[17]),
+    removedConnections: parseJsonArray(r[18]),
+    dependencies: parseJsonArray(r[19]),
+    // Phase 17.N-Q
+    skills: parseJsonArray(r[20]),
+    skillsMode: r[21] ?? "inherit",
+    claimPolicy: parseJsonOrNull(r[22]),
+    claimPolicyMode: r[23] ?? "inherit",
+    executionConfig: parseJsonOrNull(r[24]),
+    executionConfigMode: r[25] ?? "inherit",
+    // Phase 17.F
+    constraints: parseJsonOrNull(r[26]),
+    constraintsMode: r[27] ?? "inherit",
+    // Phase 17.K
+    requiresApproval: !!r[28],
+    author: r[29],
+    authorType: r[30],
+    createdAt: r[31],
+    updatedAt: r[32],
+    migratedFrom: r[33] ?? null,
+    // Phase 3.2 — per-item sharing
+    visibility: r[34] ?? "shared",
+    overrideParentVisibility: !!r[35],
+    assigneeSession: r[36] ?? null,
+    workstream: r[37] ?? null
+  };
+}
+function parseJsonArray(s) {
+  if (!s) return [];
+  try {
+    const parsed = JSON.parse(s);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function parseJsonOrNull(s) {
+  if (!s) return null;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return null;
+  }
+}
+function metaSnapshotOf(item) {
+  return {
+    title: item.title,
+    template: item.template,
+    status: item.status,
+    assignee: item.assignee,
+    assigneeType: item.assigneeType,
+    assigneeModel: item.assigneeModel,
+    progressPercent: item.progressPercent,
+    blockedReason: item.blockedReason,
+    scopePath: item.scopePath,
+    fileSpecs: item.fileSpecs,
+    symbolSpecs: item.symbolSpecs,
+    newConnections: item.newConnections,
+    removedConnections: item.removedConnections,
+    dependencies: item.dependencies,
+    parentUid: item.parentUid,
+    sortOrder: item.sortOrder,
+    // Phase 17.N-Q
+    skills: item.skills,
+    skillsMode: item.skillsMode,
+    claimPolicy: item.claimPolicy,
+    claimPolicyMode: item.claimPolicyMode,
+    executionConfig: item.executionConfig,
+    executionConfigMode: item.executionConfigMode,
+    // Phase 17.F
+    constraints: item.constraints,
+    constraintsMode: item.constraintsMode,
+    // Phase 17.K
+    requiresApproval: item.requiresApproval,
+    // Phase 3.2
+    visibility: item.visibility,
+    overrideParentVisibility: item.overrideParentVisibility,
+    // Phase 32 C5.1
+    workstream: item.workstream ?? null
+  };
+}
+function getItem(uid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT ${ITEM_COLUMNS} FROM plan_items WHERE uid = ?`,
+    [uid]
+  );
+  if (!result[0]?.values[0]) return null;
+  return rowToItem(result[0].values[0]);
+}
+function getChildren(planUid, parentUid) {
+  const db = (0, import_database.getDb)();
+  if (parentUid === null) {
+    const r2 = db.exec(
+      `SELECT ${ITEM_COLUMNS} FROM plan_items
+       WHERE plan_uid = ? AND parent_uid IS NULL
+       ORDER BY sort_order ASC, created_at ASC`,
+      [planUid]
+    );
+    return (r2[0]?.values ?? []).map(rowToItem);
+  }
+  const r = db.exec(
+    `SELECT ${ITEM_COLUMNS} FROM plan_items
+     WHERE plan_uid = ? AND parent_uid = ?
+     ORDER BY sort_order ASC, created_at ASC`,
+    [planUid, parentUid]
+  );
+  return (r[0]?.values ?? []).map(rowToItem);
+}
+function listAllItems(planUid) {
+  const r = (0, import_database.getDb)().exec(
+    `SELECT ${ITEM_COLUMNS} FROM plan_items
+     WHERE plan_uid = ?
+     ORDER BY sort_order ASC, created_at ASC`,
+    [planUid]
+  );
+  return (r[0]?.values ?? []).map(rowToItem);
+}
+function listItemSummaries(planUid) {
+  const db = (0, import_database.getDb)();
+  const r = db.exec(
+    `SELECT i.uid, i.plan_uid, i.parent_uid, i.sort_order, i.kind,
+            i.title, i.template, i.status, i.assignee, i.progress_percent,
+            (SELECT COUNT(*) FROM plan_items c WHERE c.parent_uid = i.uid) AS child_count,
+            i.visibility, i.visibility_override
+     FROM plan_items i
+     WHERE i.plan_uid = ?
+     ORDER BY i.sort_order ASC, i.created_at ASC`,
+    [planUid]
+  );
+  if (!r[0]) return [];
+  return r[0].values.map((row) => ({
+    uid: row[0],
+    planUid: row[1],
+    parentUid: row[2] ?? null,
+    sortOrder: row[3],
+    kind: row[4],
+    title: row[5],
+    template: row[6] ?? null,
+    status: row[7] ?? null,
+    assignee: row[8] ?? null,
+    progressPercent: row[9] ?? null,
+    childCount: row[10] ?? 0,
+    visibility: row[11] ?? "shared",
+    overrideParentVisibility: row[12] === 1
+  }));
+}
+function createItemImpl(input) {
+  const db = (0, import_database.getDb)();
+  const uid = input.uid ?? (0, import_node_crypto.randomUUID)();
+  assertValidParent(input.planUid, null, input.parentUid);
+  const now = Date.now();
+  const createdAt = input.createdAt ?? now;
+  const updatedAt = input.updatedAt ?? now;
+  let sortOrder = input.sortOrder;
+  if (sortOrder === void 0) {
+    const r = db.exec(
+      input.parentUid == null ? `SELECT COALESCE(MAX(sort_order), -1) + 1
+           FROM plan_items WHERE plan_uid = ? AND parent_uid IS NULL` : `SELECT COALESCE(MAX(sort_order), -1) + 1
+           FROM plan_items WHERE plan_uid = ? AND parent_uid = ?`,
+      input.parentUid == null ? [input.planUid] : [input.planUid, input.parentUid]
+    );
+    sortOrder = r[0]?.values[0]?.[0] ?? 0;
+  }
+  const isAction = input.kind === "action";
+  db.run(
+    `INSERT INTO plan_items
+       (uid, plan_uid, parent_uid, sort_order, kind,
+        title, body, template,
+        status, assignee, assignee_type, assignee_model,
+        progress_percent, blocked_reason,
+        scope_path, file_specs, symbol_specs, new_connections, removed_conns, dependencies,
+        skills, skills_mode, claim_policy, claim_policy_mode, execution_config, execution_config_mode,
+        constraints, constraints_mode, requires_approval,
+        author, author_type, created_at, updated_at, migrated_from,
+        visibility, visibility_override, workstream)
+     VALUES (?, ?, ?, ?, ?,
+             ?, ?, ?,
+             ?, ?, ?, ?,
+             ?, ?,
+             ?, ?, ?, ?, ?, ?,
+             ?, ?, ?, ?, ?, ?,
+             ?, ?, ?,
+             ?, ?, ?, ?, ?,
+             ?, ?, ?)`,
+    [
+      uid,
+      input.planUid,
+      input.parentUid ?? null,
+      sortOrder,
+      input.kind,
+      input.title,
+      input.body ?? "",
+      input.template ?? null,
+      isAction ? input.status ?? "pending" : null,
+      isAction ? input.assignee ?? null : null,
+      isAction ? input.assigneeType ?? null : null,
+      isAction ? input.assigneeModel ?? null : null,
+      // Phase 15.B — migrator preserves legacy progress / blocker
+      // values; native creation passes neither so they default null.
+      isAction ? input.progressPercent ?? null : null,
+      isAction ? input.blockedReason ?? null : null,
+      isAction ? input.scopePath ?? null : null,
+      JSON.stringify(isAction ? input.fileSpecs ?? [] : []),
+      JSON.stringify(isAction ? input.symbolSpecs ?? [] : []),
+      JSON.stringify(isAction ? input.newConnections ?? [] : []),
+      JSON.stringify(isAction ? input.removedConnections ?? [] : []),
+      JSON.stringify(isAction ? input.dependencies ?? [] : []),
+      // Phase 17.N-Q
+      // Phase 32 C1: whatever the source (panel, plan file, template), stored normalised.
+      JSON.stringify((0, import_skill_model.normaliseSkills)(input.skills).skills),
+      input.skillsMode ?? "inherit",
+      input.claimPolicy ? JSON.stringify(input.claimPolicy) : null,
+      input.claimPolicyMode ?? "inherit",
+      input.executionConfig ? JSON.stringify(input.executionConfig) : null,
+      input.executionConfigMode ?? "inherit",
+      // Phase 17.F
+      input.constraints ? JSON.stringify(input.constraints) : null,
+      input.constraintsMode ?? "inherit",
+      // Phase 17.K
+      input.requiresApproval ? 1 : 0,
+      input.author,
+      input.authorType,
+      createdAt,
+      updatedAt,
+      input.migratedFrom ?? null,
+      // Phase 3.2 — per-item sharing
+      input.visibility ?? "shared",
+      input.overrideParentVisibility ? 1 : 0,
+      // Phase 32 C5.1
+      input.workstream ?? null
+    ]
+  );
+  (0, import_persistence.markDirty)();
+  const item = getItem(uid);
+  if (!item) {
+    throw new Error(`createItem: failed to read back inserted item ${uid}`);
+  }
+  writeVersionRow(item, 1, "Created", input.author, input.authorType, createdAt);
+  (0, import_plan_event_service.appendPlanEvent)({
+    planUid: input.planUid,
+    itemUid: uid,
+    eventType: "item_created",
+    afterState: { uid, kind: input.kind, title: input.title, parentUid: input.parentUid ?? null, sortOrder },
+    summary: `${input.kind === "action" ? "\u26A1" : "\u{1F4CB}"} created "${input.title}"`,
+    author: input.author,
+    authorType: input.authorType,
+    createdAt
+  });
+  return item;
+}
+class PlanItemStructureError extends Error {
+}
+function assertValidParent(planUid, itemUid, parentUid) {
+  if (parentUid == null) return;
+  if (itemUid !== null && parentUid === itemUid) throw new PlanItemStructureError("An item cannot be its own parent");
+  const parent = getItem(parentUid);
+  if (!parent) throw new PlanItemStructureError(`No item ${parentUid} to put it under`);
+  if (parent.planUid !== planUid) throw new PlanItemStructureError("The new parent belongs to a different plan");
+  if (itemUid === null) return;
+  const seen = /* @__PURE__ */ new Set([parent.uid]);
+  for (let cursor = parent.parentUid; cursor; cursor = getItem(cursor)?.parentUid ?? null) {
+    if (cursor === itemUid) throw new PlanItemStructureError("That would put the item under one of its own sub-items");
+    if (seen.has(cursor)) break;
+    seen.add(cursor);
+  }
+}
+let statusListener = null;
+function setStatusChangeListener(fn) {
+  statusListener = fn;
+}
+let stateWriteListener = null;
+let stateFromElsewhere = 0;
+function setStateWriteListener(fn) {
+  stateWriteListener = fn;
+}
+function withoutStateRecords(fn) {
+  stateFromElsewhere++;
+  try {
+    return fn();
+  } finally {
+    stateFromElsewhere--;
+  }
+}
+function applyRecordedState(uid, state, author) {
+  return withoutStateRecords(() => updateItemImpl(uid, { ...state, ...author, changeSummary: "from a teammate's record" }));
+}
+const RECORDED_FIELDS = ["status", "assignee", "progressPercent", "blockedReason"];
+function updateItemImpl(uid, updates) {
+  const db = (0, import_database.getDb)();
+  const before = getItem(uid);
+  if (!before) return null;
+  if (updates.parentUid !== void 0 && updates.parentUid !== before.parentUid) {
+    assertValidParent(before.planUid, uid, updates.parentUid);
+  }
+  const now = Date.now();
+  const sets = ["updated_at = ?"];
+  const params = [now];
+  let contentChanged = false;
+  const structuralEvents = [];
+  if (updates.title !== void 0 && updates.title !== before.title) {
+    sets.push("title = ?");
+    params.push(updates.title);
+    contentChanged = true;
+    structuralEvents.push({
+      eventType: "item_renamed",
+      before: { title: before.title },
+      after: { title: updates.title },
+      kind: "renamed"
+    });
+  }
+  const bodyChanged = updates.body !== void 0 && updates.body !== before.body;
+  if (bodyChanged) {
+    sets.push("body = ?");
+    params.push(updates.body);
+    contentChanged = true;
+  }
+  if (updates.template !== void 0 && updates.template !== before.template) {
+    sets.push("template = ?");
+    params.push(updates.template);
+    contentChanged = true;
+  }
+  if (before.kind === "action") {
+    if (updates.status !== void 0 && updates.status !== before.status) {
+      sets.push("status = ?");
+      params.push(updates.status);
+      contentChanged = true;
+      structuralEvents.push({
+        eventType: "status_changed",
+        before: { status: before.status },
+        after: { status: updates.status },
+        kind: "status_changed"
+      });
+    }
+    if (updates.assignee !== void 0 && updates.assignee !== before.assignee) {
+      sets.push("assignee = ?");
+      params.push(updates.assignee);
+      contentChanged = true;
+    }
+    if (updates.assigneeType !== void 0 && updates.assigneeType !== before.assigneeType) {
+      sets.push("assignee_type = ?");
+      params.push(updates.assigneeType);
+      contentChanged = true;
+    }
+    if (updates.assigneeModel !== void 0 && updates.assigneeModel !== before.assigneeModel) {
+      sets.push("assignee_model = ?");
+      params.push(updates.assigneeModel);
+      contentChanged = true;
+    }
+    if (updates.assigneeSession !== void 0 && updates.assigneeSession !== (before.assigneeSession ?? null)) {
+      sets.push("assignee_session = ?");
+      params.push(updates.assigneeSession);
+    } else if (updates.assignee === null && before.assigneeSession) {
+      sets.push("assignee_session = NULL");
+    }
+    if (updates.progressPercent !== void 0 && updates.progressPercent !== before.progressPercent) {
+      sets.push("progress_percent = ?");
+      params.push(updates.progressPercent);
+      contentChanged = true;
+    }
+    if (updates.blockedReason !== void 0 && updates.blockedReason !== before.blockedReason) {
+      sets.push("blocked_reason = ?");
+      params.push(updates.blockedReason);
+      contentChanged = true;
+    }
+    if (updates.scopePath !== void 0 && updates.scopePath !== before.scopePath) {
+      sets.push("scope_path = ?");
+      params.push(updates.scopePath);
+      contentChanged = true;
+    }
+    if (updates.fileSpecs !== void 0) {
+      sets.push("file_specs = ?");
+      params.push(JSON.stringify(updates.fileSpecs));
+      contentChanged = true;
+    }
+    if (updates.symbolSpecs !== void 0) {
+      sets.push("symbol_specs = ?");
+      params.push(JSON.stringify(updates.symbolSpecs));
+      contentChanged = true;
+    }
+    if (updates.newConnections !== void 0 || updates.removedConnections !== void 0) {
+      let effectiveNew = updates.newConnections ?? before.newConnections ?? [];
+      let effectiveRemoved = updates.removedConnections ?? before.removedConnections ?? [];
+      if (effectiveNew.length > 0 && effectiveRemoved.length > 0) {
+        const edgeKey = (e) => `${e.from}\0${e.to}`;
+        const newKeys = new Set(effectiveNew.map(edgeKey));
+        const removedKeys = new Set(effectiveRemoved.map(edgeKey));
+        const dupes = new Set([...newKeys].filter((k) => removedKeys.has(k)));
+        if (dupes.size > 0) {
+          effectiveNew = effectiveNew.filter((e) => !dupes.has(edgeKey(e)));
+          effectiveRemoved = effectiveRemoved.filter((e) => !dupes.has(edgeKey(e)));
+        }
+      }
+      sets.push("new_connections = ?");
+      params.push(JSON.stringify(effectiveNew));
+      sets.push("removed_conns = ?");
+      params.push(JSON.stringify(effectiveRemoved));
+      contentChanged = true;
+    }
+    if (updates.dependencies !== void 0) {
+      sets.push("dependencies = ?");
+      params.push(JSON.stringify(updates.dependencies));
+      contentChanged = true;
+    }
+  }
+  if (updates.skills !== void 0) {
+    sets.push("skills = ?");
+    params.push(JSON.stringify((0, import_skill_model.normaliseSkills)(updates.skills).skills));
+    contentChanged = true;
+  }
+  if (updates.skillsMode !== void 0 && updates.skillsMode !== before.skillsMode) {
+    sets.push("skills_mode = ?");
+    params.push(updates.skillsMode);
+    contentChanged = true;
+  }
+  if (updates.workstream !== void 0 && (updates.workstream ?? null) !== (before.workstream ?? null)) {
+    sets.push("workstream = ?");
+    params.push(updates.workstream ?? null);
+    contentChanged = true;
+  }
+  if (updates.claimPolicy !== void 0) {
+    sets.push("claim_policy = ?");
+    params.push(updates.claimPolicy ? JSON.stringify(updates.claimPolicy) : null);
+    contentChanged = true;
+  }
+  if (updates.claimPolicyMode !== void 0 && updates.claimPolicyMode !== before.claimPolicyMode) {
+    sets.push("claim_policy_mode = ?");
+    params.push(updates.claimPolicyMode);
+    contentChanged = true;
+  }
+  if (updates.executionConfig !== void 0) {
+    sets.push("execution_config = ?");
+    params.push(updates.executionConfig ? JSON.stringify(updates.executionConfig) : null);
+    contentChanged = true;
+  }
+  if (updates.executionConfigMode !== void 0 && updates.executionConfigMode !== before.executionConfigMode) {
+    sets.push("execution_config_mode = ?");
+    params.push(updates.executionConfigMode);
+    contentChanged = true;
+  }
+  if (updates.constraints !== void 0) {
+    sets.push("constraints = ?");
+    params.push(updates.constraints ? JSON.stringify(updates.constraints) : null);
+    contentChanged = true;
+  }
+  if (updates.constraintsMode !== void 0 && updates.constraintsMode !== before.constraintsMode) {
+    sets.push("constraints_mode = ?");
+    params.push(updates.constraintsMode);
+    contentChanged = true;
+  }
+  if (updates.requiresApproval !== void 0 && updates.requiresApproval !== before.requiresApproval) {
+    sets.push("requires_approval = ?");
+    params.push(updates.requiresApproval ? 1 : 0);
+    contentChanged = true;
+  }
+  if (updates.visibility !== void 0 && updates.visibility !== before.visibility) {
+    sets.push("visibility = ?");
+    params.push(updates.visibility);
+    contentChanged = true;
+  }
+  if (updates.overrideParentVisibility !== void 0 && updates.overrideParentVisibility !== before.overrideParentVisibility) {
+    sets.push("visibility_override = ?");
+    params.push(updates.overrideParentVisibility ? 1 : 0);
+    contentChanged = true;
+  }
+  if (updates.parentUid !== void 0 && updates.parentUid !== before.parentUid) {
+    sets.push("parent_uid = ?");
+    params.push(updates.parentUid);
+    structuralEvents.push({
+      eventType: "reparented",
+      before: { parentUid: before.parentUid },
+      after: { parentUid: updates.parentUid },
+      kind: "reparented"
+    });
+  }
+  if (updates.sortOrder !== void 0 && updates.sortOrder !== before.sortOrder) {
+    sets.push("sort_order = ?");
+    params.push(updates.sortOrder);
+    structuralEvents.push({
+      eventType: "reordered",
+      before: { sortOrder: before.sortOrder },
+      after: { sortOrder: updates.sortOrder },
+      kind: "reordered"
+    });
+  }
+  if (sets.length === 1) {
+    return before;
+  }
+  params.push(uid);
+  db.run(`UPDATE plan_items SET ${sets.join(", ")} WHERE uid = ?`, params);
+  (0, import_persistence.markDirty)();
+  const after = getItem(uid);
+  if (!after) return null;
+  after.updatedAt = now;
+  if (contentChanged) {
+    const version = nextVersionFor(uid);
+    writeVersionRow(after, version, updates.changeSummary ?? null, updates.author, updates.authorType, now);
+    if (bodyChanged) {
+      (0, import_agent_event_log.recordBodyEdit)({
+        kind: "item",
+        planUid: after.planUid,
+        uid: after.uid,
+        title: after.title,
+        version,
+        author: updates.author ?? null,
+        authorType: updates.authorType ?? null,
+        changeSummary: updates.changeSummary ?? null
+      });
+    }
+  }
+  for (const ev of structuralEvents) {
+    (0, import_plan_event_service.appendPlanEvent)({
+      planUid: after.planUid,
+      itemUid: after.uid,
+      eventType: ev.eventType,
+      beforeState: ev.before,
+      afterState: ev.after,
+      summary: structuralSummary(after, ev.kind, ev.before, ev.after),
+      author: updates.author,
+      authorType: updates.authorType
+    });
+  }
+  if (statusListener && structuralEvents.some((ev) => ev.kind === "status_changed")) {
+    try {
+      statusListener({ planUid: after.planUid, itemUid: after.uid, status: after.status ?? null });
+    } catch {
+    }
+  }
+  if (stateWriteListener && !stateFromElsewhere && after.kind === "action" && RECORDED_FIELDS.some((k) => (after[k] ?? null) !== (before[k] ?? null))) {
+    try {
+      stateWriteListener(after, { author: updates.author ?? "someone", authorType: updates.authorType ?? "unknown" });
+    } catch {
+    }
+  }
+  return after;
+}
+function moveItemImpl(uid, input) {
+  const before = getItem(uid);
+  if (!before) return null;
+  if (input.newParentUid !== void 0 && input.newParentUid !== before.parentUid) {
+    assertValidParent(before.planUid, uid, input.newParentUid);
+  }
+  const now = Date.now();
+  const db = (0, import_database.getDb)();
+  const sets = ["updated_at = ?"];
+  const params = [now];
+  let isReparent = false;
+  let isReorder = false;
+  if (input.newParentUid !== void 0 && input.newParentUid !== before.parentUid) {
+    sets.push("parent_uid = ?");
+    params.push(input.newParentUid);
+    isReparent = true;
+  }
+  if (input.newSortOrder !== void 0 && input.newSortOrder !== before.sortOrder) {
+    sets.push("sort_order = ?");
+    params.push(input.newSortOrder);
+    isReorder = true;
+  }
+  if (sets.length === 1) return before;
+  params.push(uid);
+  db.run(`UPDATE plan_items SET ${sets.join(", ")} WHERE uid = ?`, params);
+  (0, import_persistence.markDirty)();
+  (0, import_plan_event_service.appendPlanEvent)({
+    planUid: before.planUid,
+    itemUid: uid,
+    eventType: isReparent ? "item_moved" : "reordered",
+    beforeState: { parentUid: before.parentUid, sortOrder: before.sortOrder },
+    afterState: {
+      parentUid: input.newParentUid ?? before.parentUid,
+      sortOrder: input.newSortOrder ?? before.sortOrder
+    },
+    summary: input.summary ?? defaultMoveSummary(before, isReparent, isReorder),
+    author: input.author,
+    authorType: input.authorType
+  });
+  return getItem(uid);
+}
+function deleteItemImpl(uid, input) {
+  const db = (0, import_database.getDb)();
+  const root = getItem(uid);
+  if (!root) return [];
+  const cascade = input.cascade !== false;
+  const toDelete = cascade ? collectSubtree(uid) : [uid];
+  const beforeSnapshots = [];
+  for (const u of toDelete) {
+    const item = getItem(u);
+    if (item) beforeSnapshots.push({ uid: u, row: item });
+  }
+  for (const u of [...toDelete].reverse()) {
+    db.run(`DELETE FROM plan_item_versions WHERE item_uid = ?`, [u]);
+    db.run(`DELETE FROM plan_items WHERE uid = ?`, [u]);
+  }
+  (0, import_persistence.markDirty)();
+  (0, import_plan_event_service.appendPlanEvent)({
+    planUid: root.planUid,
+    itemUid: uid,
+    eventType: "item_deleted",
+    beforeState: { items: beforeSnapshots, cascade },
+    summary: cascade && toDelete.length > 1 ? `\u{1F5D1} deleted "${root.title}" + ${toDelete.length - 1} child${toDelete.length === 2 ? "" : "ren"}` : `\u{1F5D1} deleted "${root.title}"`,
+    author: input.author,
+    authorType: input.authorType
+  });
+  return toDelete;
+}
+function collectSubtree(rootUid) {
+  const db = (0, import_database.getDb)();
+  const result = [];
+  const stack = [rootUid];
+  while (stack.length > 0) {
+    const u = stack.pop();
+    result.push(u);
+    const r = db.exec(`SELECT uid FROM plan_items WHERE parent_uid = ?`, [u]);
+    if (r[0]) {
+      for (const row of r[0].values) stack.push(row[0]);
+    }
+  }
+  return result;
+}
+function nextVersionFor(itemUid) {
+  const r = (0, import_database.getDb)().exec(
+    `SELECT COALESCE(MAX(version), 0) + 1 FROM plan_item_versions WHERE item_uid = ?`,
+    [itemUid]
+  );
+  return r[0]?.values[0]?.[0] ?? 1;
+}
+function writeVersionRow(item, version, changeSummary, author, authorType, createdAt) {
+  (0, import_database.getDb)().run(
+    `INSERT INTO plan_item_versions
+       (item_uid, version, body_snapshot, meta_snapshot, change_summary, author, author_type, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      item.uid,
+      version,
+      item.body ?? "",
+      JSON.stringify(metaSnapshotOf(item)),
+      changeSummary,
+      author,
+      authorType,
+      createdAt
+    ]
+  );
+}
+function listItemVersions(itemUid) {
+  const r = (0, import_database.getDb)().exec(
+    `SELECT id, item_uid, version, body_snapshot, meta_snapshot, change_summary, author, author_type, created_at
+     FROM plan_item_versions
+     WHERE item_uid = ?
+     ORDER BY version DESC`,
+    [itemUid]
+  );
+  if (!r[0]) return [];
+  return r[0].values.map((row) => ({
+    id: row[0],
+    itemUid: row[1],
+    version: row[2],
+    bodySnapshot: row[3] ?? "",
+    metaSnapshot: parseJsonObj(row[4]),
+    changeSummary: row[5] ?? null,
+    author: row[6],
+    authorType: row[7],
+    createdAt: row[8]
+  }));
+}
+function parseJsonObj(s) {
+  if (!s) return {};
+  try {
+    const v = JSON.parse(s);
+    return typeof v === "object" && v !== null ? v : {};
+  } catch {
+    return {};
+  }
+}
+function restoreItemVersion(itemUid, version, author, authorType) {
+  const versions = listItemVersions(itemUid);
+  const target = versions.find((v) => v.version === version);
+  if (!target) return null;
+  const meta = target.metaSnapshot;
+  const updates = {
+    body: target.bodySnapshot,
+    title: typeof meta.title === "string" ? meta.title : void 0,
+    template: meta.template === null || typeof meta.template === "string" ? meta.template : void 0,
+    status: typeof meta.status === "string" ? meta.status : void 0,
+    assignee: typeof meta.assignee === "string" || meta.assignee === null ? meta.assignee : void 0,
+    assigneeType: typeof meta.assigneeType === "string" || meta.assigneeType === null ? meta.assigneeType : void 0,
+    assigneeModel: typeof meta.assigneeModel === "string" || meta.assigneeModel === null ? meta.assigneeModel : void 0,
+    progressPercent: typeof meta.progressPercent === "number" || meta.progressPercent === null ? meta.progressPercent : void 0,
+    blockedReason: typeof meta.blockedReason === "string" || meta.blockedReason === null ? meta.blockedReason : void 0,
+    scopePath: typeof meta.scopePath === "string" || meta.scopePath === null ? meta.scopePath : void 0,
+    fileSpecs: Array.isArray(meta.fileSpecs) ? meta.fileSpecs : void 0,
+    symbolSpecs: Array.isArray(meta.symbolSpecs) ? meta.symbolSpecs : void 0,
+    newConnections: Array.isArray(meta.newConnections) ? meta.newConnections : void 0,
+    removedConnections: Array.isArray(meta.removedConnections) ? meta.removedConnections : void 0,
+    dependencies: Array.isArray(meta.dependencies) ? meta.dependencies : void 0,
+    changeSummary: `Restored v${version}`,
+    author,
+    authorType
+  };
+  const restored = updateItem(itemUid, updates);
+  if (!restored) return null;
+  (0, import_plan_event_service.appendPlanEvent)({
+    planUid: restored.planUid,
+    itemUid,
+    eventType: "item_restored",
+    afterState: { restoredFromVersion: version },
+    summary: `\u21A9 restored "${restored.title}" to v${version}`,
+    author,
+    authorType
+  });
+  return restored;
+}
+function sameClaimant(other, agentId, sessionId) {
+  if (sessionId && other.assigneeSession) return other.assigneeSession === sessionId;
+  return other.assignee === agentId;
+}
+function resolveClaimPolicy(item) {
+  return resolveClaimPolicyWithSource(item).value;
+}
+function resolveClaimPolicyWithSource(item) {
+  let cur = item;
+  while (cur) {
+    if (cur.claimPolicy) return { value: cur.claimPolicy, fromUid: cur.uid, fromTitle: cur.title };
+    cur = cur.parentUid ? getItem(cur.parentUid) : null;
+  }
+  return { value: { mode: "any" }, fromUid: null, fromTitle: null };
+}
+function resolveExecutionConfigWithSource(item) {
+  let cur = item;
+  while (cur) {
+    if (cur.executionConfig) return { value: cur.executionConfig, fromUid: cur.uid, fromTitle: cur.title };
+    cur = cur.parentUid ? getItem(cur.parentUid) : null;
+  }
+  return { value: null, fromUid: null, fromTitle: null };
+}
+function resolveSkills(item) {
+  const chain = [];
+  let cur = item;
+  while (cur) {
+    chain.unshift(cur);
+    cur = cur.parentUid ? getItem(cur.parentUid) : null;
+  }
+  let resolved = [];
+  for (const ancestor of chain) {
+    const skills = ancestor.skills ?? [];
+    if (skills.length === 0 && ancestor.skillsMode === "inherit") continue;
+    if (ancestor.skillsMode === "replace") {
+      resolved = [...skills];
+    } else if (ancestor.skillsMode === "none") {
+      resolved = [];
+    } else {
+      const byName = new Map(resolved.map((s) => [s.name, s]));
+      for (const s of skills) byName.set(s.name, s);
+      resolved = Array.from(byName.values());
+    }
+  }
+  return resolved;
+}
+function resolveSkillsWithSource(item) {
+  const chain = [];
+  let cur = item;
+  while (cur) {
+    chain.unshift(cur);
+    cur = cur.parentUid ? getItem(cur.parentUid) : null;
+  }
+  let resolved = /* @__PURE__ */ new Map();
+  for (const ancestor of chain) {
+    const skills = ancestor.skills ?? [];
+    if (skills.length === 0 && ancestor.skillsMode === "inherit") continue;
+    const here = skills.map((skill) => [skill.name, { skill, fromUid: ancestor.uid, fromTitle: ancestor.title }]);
+    if (ancestor.skillsMode === "replace") resolved = new Map(here);
+    else if (ancestor.skillsMode === "none") resolved = /* @__PURE__ */ new Map();
+    else for (const [k, v] of here) resolved.set(k, v);
+  }
+  return [...resolved.values()];
+}
+function resolveConstraints(item) {
+  return resolveConstraintsWithSource(item).value;
+}
+function resolveConstraintsWithSource(item) {
+  const chain = [];
+  let cur = item;
+  while (cur) {
+    chain.unshift(cur);
+    cur = cur.parentUid ? getItem(cur.parentUid) : null;
+  }
+  let resolved = {};
+  let from = null;
+  for (const ancestor of chain) {
+    const c = ancestor.constraints;
+    const mode = ancestor.constraintsMode ?? "inherit";
+    if (mode === "none") {
+      resolved = {};
+      from = ancestor;
+      continue;
+    }
+    if (mode === "replace" && c) {
+      resolved = { ...c };
+      from = ancestor;
+      continue;
+    }
+    if (!c) continue;
+    resolved = {
+      excludePaths: [...resolved.excludePaths ?? [], ...c.excludePaths ?? []],
+      excludeSymbols: [...resolved.excludeSymbols ?? [], ...c.excludeSymbols ?? []],
+      lockInterfaces: resolved.lockInterfaces || c.lockInterfaces || false,
+      requireTests: resolved.requireTests || c.requireTests || false,
+      requireLint: resolved.requireLint || c.requireLint || false,
+      maxFilesTouched: c.maxFilesTouched ?? resolved.maxFilesTouched ?? null,
+      maxLinesChanged: c.maxLinesChanged ?? resolved.maxLinesChanged ?? null,
+      customRules: [...resolved.customRules ?? [], ...c.customRules ?? []]
+    };
+    from = ancestor;
+  }
+  return { value: resolved, fromUid: from?.uid ?? null, fromTitle: from?.title ?? null };
+}
+function claimItemImpl(uid, agentId, agentType, model, capabilities, sessionId, actor) {
+  const item = getItem(uid);
+  if (!item) return { ok: false, reason: "Item not found" };
+  if (item.kind !== "action") {
+    return { ok: false, reason: "Only Actions can be claimed (this is an Object)." };
+  }
+  if (item.assignee || item.status !== "pending") {
+    return { ok: false, reason: "Action already claimed or not pending." };
+  }
+  const policy = resolveClaimPolicy(item);
+  if (policy.mode === "human-only") {
+    return { ok: false, reason: "This task is restricted to human-only completion." };
+  }
+  if (policy.mode === "assigned") {
+    if (policy.assignToType === "human") {
+      return { ok: false, reason: "This task is assigned to a human." };
+    }
+    if (policy.assignTo && policy.assignTo !== agentId) {
+      return { ok: false, reason: `This task is assigned to a specific agent (${policy.assignTo}).` };
+    }
+  }
+  if (policy.allowedAgentTypes && policy.allowedAgentTypes.length > 0) {
+    if (!policy.allowedAgentTypes.includes(agentType)) {
+      return { ok: false, reason: `This task is restricted to agent types: ${policy.allowedAgentTypes.join(", ")}. You are: ${agentType}.` };
+    }
+  }
+  if (policy.allowedModels && policy.allowedModels.length > 0 && model) {
+    if (!policy.allowedModels.includes(model)) {
+      return { ok: false, reason: `This task is restricted to models: ${policy.allowedModels.join(", ")}. You are using: ${model}.` };
+    }
+  }
+  if (policy.mode === "match-skills" || policy.mode === "any") {
+    const requiredSkills = resolveSkills(item).filter((s) => s.required);
+    if (requiredSkills.length > 0 && capabilities) {
+      const capNames = new Set(capabilities.map((c) => c.name));
+      const missing = requiredSkills.filter((s) => !capNames.has(s.name));
+      if (missing.length > 0) {
+        return {
+          ok: false,
+          reason: `This task requires skills you don't have: ${missing.map((s) => `${s.name} (${s.source})`).join(", ")}.`
+        };
+      }
+    } else if (requiredSkills.length > 0 && !capabilities) {
+      if (policy.mode === "match-skills") {
+        return {
+          ok: false,
+          reason: `This task requires skills (${requiredSkills.map((s) => s.name).join(", ")}) but you haven't declared capabilities. Use register_session with capabilities.`
+        };
+      }
+    }
+  }
+  const myFiles = /* @__PURE__ */ new Set();
+  for (const fs of item.fileSpecs ?? []) {
+    if (fs.path) myFiles.add(fs.path);
+    if (fs.moveTo) myFiles.add(fs.moveTo);
+  }
+  const conflicts = [];
+  if (myFiles.size > 0) {
+    const others = listAllItems(item.planUid).filter(
+      (o) => o.uid !== uid && o.kind === "action" && (o.status === "in_progress" || o.status === "assigned") && !sameClaimant(o, agentId, sessionId)
+    );
+    for (const other of others) {
+      const overlap = (other.fileSpecs ?? []).flatMap((fs) => [fs.path, fs.moveTo].filter(Boolean)).filter((p) => myFiles.has(p));
+      if (overlap.length > 0) {
+        conflicts.push(`Action "${other.title}" (${other.assignee}) also affects: ${overlap.join(", ")}`);
+      }
+    }
+  }
+  updateItem(uid, {
+    status: "assigned",
+    assignee: agentId,
+    assigneeType: agentType,
+    assigneeModel: model ?? null,
+    assigneeSession: sessionId ?? null,
+    // Who made the claim, from how it arrived: the agent itself over MCP,
+    // the person (or `unverified`) over REST, which can claim on an agent's
+    // behalf. The claimant alone when no caller is given.
+    author: actor?.author ?? agentId,
+    authorType: actor?.authorType ?? "agent",
+    changeSummary: "Claimed"
+  });
+  const waiting = item.kind === "action" ? dependencyStateOf(item) : null;
+  return {
+    ok: true,
+    conflicts: conflicts.length > 0 ? conflicts : void 0,
+    waitsOn: waiting && !waiting.met ? waiting.waits.map((w) => w.words) : void 0
+  };
+}
+const dependencyLookup = {
+  getItem,
+  planTitle(planUid) {
+    const r = (0, import_database.getDb)().exec("SELECT title FROM plans WHERE uid = ?", [planUid]);
+    return r[0]?.values[0]?.[0] ?? null;
+  }
+};
+function dependencyStateOf(item, local) {
+  return (0, import_plan_dependencies.dependencyState)(item, dependencyLookup, local);
+}
+function planWaits(planUid) {
+  const all = listAllItems(planUid);
+  const local = new Map(all.map((i) => [i.uid, i]));
+  const out = [];
+  for (const item of all) {
+    if (item.kind !== "action" || item.status !== "pending") continue;
+    const state = dependencyStateOf(item, local);
+    if (!state.met) out.push({ itemUid: item.uid, itemTitle: item.title, waits: state.waits, sentence: (0, import_plan_dependencies.waitSentence)(item.title, state) });
+  }
+  return out;
+}
+function getNextItem(planUid, parentUid, accept) {
+  const all = listAllItems(planUid);
+  const local = new Map(all.map((i) => [i.uid, i]));
+  let candidates = all.filter(
+    (i) => i.kind === "action" && i.status === "pending" && !i.assignee && (!accept || accept(i))
+  );
+  if (parentUid !== void 0) {
+    candidates = candidates.filter((i) => i.parentUid === parentUid);
+  }
+  const held = [];
+  candidates = candidates.filter((i) => {
+    const state = dependencyStateOf(i, local);
+    if (!state.met) held.push({ item: i, state });
+    return state.met;
+  });
+  candidates.sort((a, b) => a.sortOrder - b.sortOrder);
+  if (candidates.length === 0) {
+    const first = held.sort((a, b) => a.item.sortOrder - b.item.sortOrder)[0];
+    return first ? { item: null, waiting: { itemUid: first.item.uid, itemTitle: first.item.title, reason: (0, import_plan_dependencies.waitSentence)(first.item.title, first.state) } } : { item: null };
+  }
+  const next = candidates[0];
+  const siblings = all.filter((i) => i.parentUid === next.parentUid && i.kind === "action").sort((a, b) => a.sortOrder - b.sortOrder);
+  const myIdx = siblings.findIndex((s) => s.uid === next.uid);
+  if (myIdx > 0) {
+    const prev = siblings[myIdx - 1];
+    const unmet = prev.status === "done" ? (0, import_criteria_service.unmetHumanCriteria)(prev.uid) : [];
+    if (unmet.length > 0) {
+      return {
+        item: null,
+        gated: {
+          itemUid: next.uid,
+          itemTitle: next.title,
+          reason: `Waiting for a person to sign off "${prev.title}" (${unmet.map((c) => `"${c.text}"`).join(", ")}) before proceeding.`
+        }
+      };
+    }
+  }
+  return { item: next };
+}
+function structuralSummary(after, kind, beforeState, afterState) {
+  const icon = after.kind === "action" ? "\u26A1" : "\u{1F4CB}";
+  switch (kind) {
+    case "renamed": {
+      const b = beforeState?.title ?? "?";
+      return `${icon} renamed "${b}" \u2192 "${after.title}"`;
+    }
+    case "status_changed": {
+      const b = beforeState?.status ?? "?";
+      const a = afterState?.status ?? "?";
+      return `${icon} "${after.title}" ${b} \u2192 ${a}`;
+    }
+    case "reparented":
+      return `${icon} moved "${after.title}"`;
+    case "reordered":
+      return `${icon} reordered "${after.title}"`;
+    case "kind_transmuted":
+      return `${icon} transmuted "${after.title}"`;
+  }
+}
+function defaultMoveSummary(item, isReparent, isReorder) {
+  const icon = item.kind === "action" ? "\u26A1" : "\u{1F4CB}";
+  if (isReparent && isReorder) return `${icon} moved "${item.title}"`;
+  if (isReparent) return `${icon} re-parented "${item.title}"`;
+  return `${icon} reordered "${item.title}"`;
+}
+function getEffectiveVisibility(itemUid) {
+  const item = getItem(itemUid);
+  if (!item) return "shared";
+  if (item.visibility === "local") return "local";
+  if (item.overrideParentVisibility) return "shared";
+  let cursor = item.parentUid;
+  const seen = /* @__PURE__ */ new Set([itemUid]);
+  while (cursor) {
+    if (seen.has(cursor)) break;
+    seen.add(cursor);
+    const ancestor = getItem(cursor);
+    if (!ancestor) break;
+    if (ancestor.visibility === "local") return "local";
+    if (ancestor.overrideParentVisibility) return "shared";
+    cursor = ancestor.parentUid;
+  }
+  return "shared";
+}
+function listItemsForExport(planUid) {
+  const all = listAllItems(planUid);
+  const byUid = new Map(all.map((i) => [i.uid, i]));
+  const visibilityCache = /* @__PURE__ */ new Map();
+  function effective(uid) {
+    const cached = visibilityCache.get(uid);
+    if (cached) return cached;
+    const item = byUid.get(uid);
+    if (!item) {
+      visibilityCache.set(uid, "shared");
+      return "shared";
+    }
+    if (item.visibility === "local") {
+      visibilityCache.set(uid, "local");
+      return "local";
+    }
+    if (item.overrideParentVisibility) {
+      visibilityCache.set(uid, "shared");
+      return "shared";
+    }
+    if (!item.parentUid) {
+      visibilityCache.set(uid, "shared");
+      return "shared";
+    }
+    const parentEff = effective(item.parentUid);
+    visibilityCache.set(uid, parentEff);
+    return parentEff;
+  }
+  const result = [];
+  for (const item of all) {
+    if (effective(item.uid) !== "shared") continue;
+    let exportParentUid = null;
+    let cursor = item.parentUid;
+    const seen = /* @__PURE__ */ new Set([item.uid]);
+    while (cursor) {
+      if (seen.has(cursor)) break;
+      seen.add(cursor);
+      if (effective(cursor) === "shared") {
+        exportParentUid = cursor;
+        break;
+      }
+      const ancestor = byUid.get(cursor);
+      if (!ancestor) break;
+      cursor = ancestor.parentUid;
+    }
+    result.push({ item, exportParentUid });
+  }
+  return result;
+}
+function writeThrough(planUid) {
+  if (!planUid) return;
+  try {
+    _lazy___plan_file_service.scheduleWriteThrough(planUid);
+  } catch {
+  }
+}
+function createItem(input) {
+  const item = createItemImpl(input);
+  writeThrough(item.planUid);
+  return item;
+}
+function updateItem(uid, updates) {
+  const item = updateItemImpl(uid, updates);
+  if (!(0, import_item_status.isStateOnly)(updates)) writeThrough(item?.planUid);
+  return item;
+}
+function moveItem(uid, input) {
+  const item = moveItemImpl(uid, input);
+  writeThrough(item?.planUid);
+  return item;
+}
+function deleteItem(uid, input) {
+  const planUid = getItem(uid)?.planUid;
+  const deleted = deleteItemImpl(uid, input);
+  if (deleted.length) {
+    const marks = deleted.map(() => "?").join(",");
+    (0, import_database.getDb)().run(`DELETE FROM spec_links WHERE item_uid IN (${marks}) OR page_uid IN (${marks})`, [...deleted, ...deleted]);
+    (0, import_spec_proposal_withdraw.withdrawProposals)({ pageUids: deleted }, "The page was deleted.");
+    writeThrough(planUid);
+  }
+  return deleted;
+}
+function claimItem(uid, agentId, agentType, model, capabilities, sessionId, actor) {
+  return claimItemImpl(uid, agentId, agentType, model, capabilities, sessionId, actor);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlanItemStructureError,
+  applyRecordedState,
+  assertValidParent,
+  claimItem,
+  createItem,
+  deleteItem,
+  dependencyLookup,
+  dependencyStateOf,
+  getChildren,
+  getEffectiveVisibility,
+  getItem,
+  getNextItem,
+  listAllItems,
+  listItemSummaries,
+  listItemVersions,
+  listItemsForExport,
+  moveItem,
+  planWaits,
+  resolveClaimPolicy,
+  resolveClaimPolicyWithSource,
+  resolveConstraints,
+  resolveConstraintsWithSource,
+  resolveExecutionConfigWithSource,
+  resolveSkills,
+  resolveSkillsWithSource,
+  restoreItemVersion,
+  setStateWriteListener,
+  setStatusChangeListener,
+  updateItem,
+  withoutStateRecords
+});