hyper-pm 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -7622,6 +7622,20 @@ var envSchema = external_exports.object({
   HYPER_PM_AI_API_KEY: external_exports.string().optional(),
   /** Optional override for hyper-pm JSONL event `actor` on CLI mutations. */
   HYPER_PM_ACTOR: external_exports.string().optional(),
+  /**
+   * Optional `git user.name` for hyper-pm data-branch commits when repo git
+   * identity is unset (falls back after `GIT_AUTHOR_*`, then a built-in default).
+   */
+  HYPER_PM_GIT_USER_NAME: external_exports.string().optional(),
+  /**
+   * Optional `git user.email` for hyper-pm data-branch commits when repo git
+   * identity is unset (falls back after `GIT_AUTHOR_*`, then a built-in default).
+   */
+  HYPER_PM_GIT_USER_EMAIL: external_exports.string().optional(),
+  /** Standard Git override for commit author name (optional). */
+  GIT_AUTHOR_NAME: external_exports.string().optional(),
+  /** Standard Git override for commit author email (optional). */
+  GIT_AUTHOR_EMAIL: external_exports.string().optional(),
   /**
    * Absolute path to the hyper-pm CLI bundle (`main.cjs`) for hyper-pm-mcp and
    * other integrations when auto-resolution from the `hyper-pm` package is insufficient.
@@ -11526,6 +11540,103 @@ var normalizeTicketBranchListFromPayloadValue = (value) => {
   return normalizeTicketBranchListFromStrings(strings);
 };
 
+// src/lib/ticket-depends-on.ts
+var normalizeTicketDependsOnIds = (ids) => {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of ids) {
+    const t = raw.trim();
+    if (t === "") continue;
+    if (seen.has(t)) continue;
+    seen.add(t);
+    out.push(t);
+  }
+  return out;
+};
+var ticketDependsOnListsEqual = (a, b) => {
+  const an = normalizeTicketDependsOnIds(a ?? []);
+  const bn = normalizeTicketDependsOnIds(b ?? []);
+  if (an.length !== bn.length) return false;
+  return an.every((x, i) => x === bn[i]);
+};
+var parseTicketDependsOnFromPayloadValue = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const strings = [];
+  for (const x of value) {
+    if (typeof x !== "string") return void 0;
+    strings.push(x);
+  }
+  return normalizeTicketDependsOnIds(strings);
+};
+var parseTicketDependsOnFromFenceValue = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const strings = [];
+  for (const x of value) {
+    if (typeof x === "string") strings.push(x);
+  }
+  return normalizeTicketDependsOnIds(strings);
+};
+var wouldTicketDependsOnCreateCycle = (params) => {
+  const { fromTicketId, nextDependsOn, successorsFor } = params;
+  const dfsFromPrerequisite = (start) => {
+    const stack = [start];
+    const visited = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node === fromTicketId) return true;
+      if (visited.has(node)) continue;
+      visited.add(node);
+      const next = successorsFor(node) ?? [];
+      for (let i = next.length - 1; i >= 0; i -= 1) {
+        stack.push(next[i]);
+      }
+    }
+    return false;
+  };
+  for (const p of nextDependsOn) {
+    if (dfsFromPrerequisite(p)) return true;
+  }
+  return false;
+};
+var ticketDependsOnSuccessorsForProjection = (projection, fromTicketId, nextDependsOn) => {
+  return (ticketId) => {
+    if (ticketId === fromTicketId) {
+      return nextDependsOn.length > 0 ? nextDependsOn : void 0;
+    }
+    const row = projection.tickets.get(ticketId);
+    if (!row || row.deleted) return void 0;
+    return row.dependsOn;
+  };
+};
+var validateTicketDependsOnForWrite = (params) => {
+  const { projection, fromTicketId, nextDependsOn } = params;
+  for (const id of nextDependsOn) {
+    if (id === fromTicketId) {
+      return `Ticket cannot depend on itself (${id})`;
+    }
+    const row = projection.tickets.get(id);
+    if (row === void 0) {
+      return `Dependency ticket not found: ${id}`;
+    }
+    if (row.deleted) {
+      return `Dependency ticket deleted: ${id}`;
+    }
+  }
+  const successorsFor = ticketDependsOnSuccessorsForProjection(
+    projection,
+    fromTicketId,
+    nextDependsOn
+  );
+  if (wouldTicketDependsOnCreateCycle({
+    fromTicketId,
+    nextDependsOn,
+    successorsFor
+  })) {
+    return "Ticket dependencies would create a cycle";
+  }
+  return void 0;
+};
+
 // src/lib/ticket-planning-fields.ts
 var PRIORITY_SET = /* @__PURE__ */ new Set([
   "low",
@@ -11694,6 +11805,9 @@ var formatOutput = (format, value) => {
   return JSON.stringify(value);
 };
 
+// src/cli/normalize-raw-cli-argv.ts
+var normalizeRawCliArgv = (argv) => argv.map((token) => token === "--no-github" ? "--skip-network" : token);
+
 // src/cli/prune-unchanged-work-item-update-payload.ts
 var branchListsEqual = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
 var pruneEpicOrStoryUpdatePayloadAgainstRow = (cur, draft) => {
@@ -11749,6 +11863,20 @@ var pruneTicketUpdatePayloadAgainstRow = (cur, draft) => {
       out["labels"] = draft["labels"];
     }
   }
+  if (draft["dependsOn"] !== void 0) {
+    if (draft["dependsOn"] === null) {
+      if (!ticketDependsOnListsEqual(cur.dependsOn, [])) {
+        out["dependsOn"] = null;
+      }
+    } else {
+      const parsed = parseTicketDependsOnFromPayloadValue(draft["dependsOn"]);
+      if (parsed !== void 0) {
+        if (!ticketDependsOnListsEqual(cur.dependsOn, parsed)) {
+          out["dependsOn"] = parsed;
+        }
+      }
+    }
+  }
   if (draft["priority"] !== void 0) {
     const curP = cur.priority ?? null;
     const nextP = draft["priority"] === null ? null : draft["priority"];
@@ -11915,6 +12043,20 @@ var workItemUpdateAspects = (kind, payload) => {
       }
     }
   }
+  if (kind === "ticket" && payload["dependsOn"] !== void 0) {
+    if (payload["dependsOn"] === null) {
+      aspects.push("cleared ticket dependencies");
+    } else {
+      const d = normalizeBranchList(payload["dependsOn"]);
+      if (d.length > 0 && d.length <= MAX_BRANCH_NAMES_TO_LIST) {
+        aspects.push(`set ticket dependencies to (${d.join(", ")})`);
+      } else if (d.length > MAX_BRANCH_NAMES_TO_LIST) {
+        aspects.push("updated ticket dependencies");
+      } else {
+        aspects.push("cleared ticket dependencies");
+      }
+    }
+  }
   if (kind === "ticket" && payload["priority"] !== void 0) {
     if (payload["priority"] === null) {
       aspects.push("cleared priority");
@@ -12021,6 +12163,7 @@ var buildAuditLinkMetadata = (evt, githubRepo) => {
       if (p["status"] !== void 0) meta["status"] = String(p["status"]);
       if (p["assignee"] !== void 0) meta["assignee"] = p["assignee"];
       if (p["labels"] !== void 0) meta["labels"] = p["labels"];
+      if (p["dependsOn"] !== void 0) meta["dependsOn"] = p["dependsOn"];
       if (p["priority"] !== void 0) meta["priority"] = p["priority"];
       if (p["size"] !== void 0) meta["size"] = p["size"];
       if (p["estimate"] !== void 0) meta["estimate"] = p["estimate"];
@@ -12088,6 +12231,14 @@ var formatEpicStoryTicketCreated = (evt, entity) => {
         parts.push("with labels");
       }
     }
+    if (p["dependsOn"] !== void 0) {
+      const d = normalizeBranchList(p["dependsOn"]);
+      if (d.length > 0 && d.length <= MAX_BRANCH_NAMES_TO_LIST) {
+        parts.push(`depending on (${d.join(", ")})`);
+      } else if (d.length > MAX_BRANCH_NAMES_TO_LIST) {
+        parts.push("with ticket dependencies");
+      }
+    }
     if (p["priority"] !== void 0) {
       parts.push(`with priority ${quoteStatus(String(p["priority"]))}`);
     }
@@ -12181,6 +12332,18 @@ var formatAuditHumanSentence = (evt) => {
           bits.push("updated labels");
         }
       }
+      if (p["dependsOn"] !== void 0) {
+        if (p["dependsOn"] === null) {
+          bits.push("cleared ticket dependencies");
+        } else {
+          const d = normalizeBranchList(p["dependsOn"]);
+          if (d.length > 0 && d.length <= MAX_BRANCH_NAMES_TO_LIST) {
+            bits.push(`dependencies: ${d.join(", ")}`);
+          } else {
+            bits.push("updated ticket dependencies");
+          }
+        }
+      }
       if (p["priority"] !== void 0) {
         bits.push("updated priority");
       }
@@ -12460,6 +12623,13 @@ var ticketMatchesTicketListQuery = (ticket, projection, query) => {
       return false;
     }
   }
+  const dependsOnIncludesId = query.dependsOnIncludesId;
+  if (dependsOnIncludesId !== void 0) {
+    const deps = ticket.dependsOn ?? [];
+    if (!deps.includes(dependsOnIncludesId)) {
+      return false;
+    }
+  }
   return true;
 };
 
@@ -12665,6 +12835,7 @@ var listActiveTicketSummaries = (projection, options) => {
       ...t.estimate !== void 0 ? { estimate: t.estimate } : {},
       ...t.startWorkAt !== void 0 ? { startWorkAt: t.startWorkAt } : {},
       ...t.targetFinishAt !== void 0 ? { targetFinishAt: t.targetFinishAt } : {},
+      ...t.dependsOn !== void 0 && t.dependsOn.length > 0 ? { dependsOn: t.dependsOn } : {},
       ...t.linkedBranches.length > 0 ? { linkedBranches: t.linkedBranches } : {},
       ...last !== void 0 ? {
         lastPrActivity: {
@@ -12761,6 +12932,17 @@ var inboundTicketPlanningPayloadFromFenceMeta = (meta) => {
       }
     }
   }
+  if (Object.prototype.hasOwnProperty.call(meta, "depends_on")) {
+    const v = meta["depends_on"];
+    if (v === null) {
+      out["dependsOn"] = null;
+    } else {
+      const parsed = parseTicketDependsOnFromFenceValue(v);
+      if (parsed !== void 0) {
+        out["dependsOn"] = parsed;
+      }
+    }
+  }
   return out;
 };
 var buildGithubIssueBody = (params) => {
@@ -12786,6 +12968,9 @@ var buildGithubIssueBody = (params) => {
     if (p.targetFinishAt !== void 0) {
       meta.target_finish_at = p.targetFinishAt;
     }
+    if (p.dependsOn !== void 0 && p.dependsOn.length > 0) {
+      meta.depends_on = p.dependsOn;
+    }
   }
   return `${params.description.trim()}
 
@@ -12811,6 +12996,9 @@ var ticketPlanningForGithubIssueBody = (ticket) => {
   if (ticket.targetFinishAt !== void 0) {
     out.targetFinishAt = ticket.targetFinishAt;
   }
+  if (ticket.dependsOn !== void 0 && ticket.dependsOn.length > 0) {
+    out.dependsOn = ticket.dependsOn;
+  }
   return Object.keys(out).length > 0 ? out : void 0;
 };
 
@@ -13363,6 +13551,33 @@ var tryReadGithubOwnerRepoSlugFromGit = async (params) => {
   }
 };
 
+// src/git/resolve-effective-git-author-for-data-commit.ts
+var defaultDataCommitName = "hyper-pm";
+var defaultDataCommitEmail = "hyper-pm@users.noreply.github.com";
+var tryReadGitConfigUserName = async (cwd, runGit2) => {
+  try {
+    const { stdout } = await runGit2(cwd, ["config", "--get", "user.name"]);
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+};
+var tryReadGitConfigUserEmail = async (cwd, runGit2) => {
+  try {
+    const { stdout } = await runGit2(cwd, ["config", "--get", "user.email"]);
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+};
+var resolveEffectiveGitAuthorForDataCommit = async (cwd, runGit2, authorEnv) => {
+  const fromGitName = await tryReadGitConfigUserName(cwd, runGit2);
+  const fromGitEmail = await tryReadGitConfigUserEmail(cwd, runGit2);
+  const name = fromGitName || authorEnv.HYPER_PM_GIT_USER_NAME?.trim() || authorEnv.GIT_AUTHOR_NAME?.trim() || defaultDataCommitName;
+  const email = fromGitEmail || authorEnv.HYPER_PM_GIT_USER_EMAIL?.trim() || authorEnv.GIT_AUTHOR_EMAIL?.trim() || defaultDataCommitEmail;
+  return { name, email };
+};
+
 // src/run/commit-data.ts
 var maxActorSuffixLen = 60;
 var formatDataBranchCommitMessage = (base, actorSuffix) => {
@@ -13374,11 +13589,205 @@ var formatDataBranchCommitMessage = (base, actorSuffix) => {
   const suffix = collapsed.length > maxActorSuffixLen ? `${collapsed.slice(0, maxActorSuffixLen - 1)}\u2026` : collapsed;
   return `${base} (${suffix})`;
 };
-var commitDataWorktreeIfNeeded = async (worktreePath, message, runGit2) => {
+var commitDataWorktreeIfNeeded = async (worktreePath, message, runGit2, opts) => {
   const { stdout } = await runGit2(worktreePath, ["status", "--porcelain"]);
   if (!stdout.trim()) return;
   await runGit2(worktreePath, ["add", "."]);
-  await runGit2(worktreePath, ["commit", "-m", message]);
+  const authorEnv = opts?.authorEnv ?? env;
+  const { name, email } = await resolveEffectiveGitAuthorForDataCommit(
+    worktreePath,
+    runGit2,
+    authorEnv
+  );
+  await runGit2(worktreePath, [
+    "-c",
+    `user.name=${name}`,
+    "-c",
+    `user.email=${email}`,
+    "commit",
+    "-m",
+    message
+  ]);
+};
+
+// src/run/push-data-branch.ts
+var firstLineFromUnknown = (err) => {
+  const raw = err instanceof Error ? err.message : String(err);
+  const line = raw.trim().split("\n")[0]?.trim() ?? raw.trim();
+  return line.length > 0 ? line : "git error";
+};
+var tryPushDataBranchToRemote = async (worktreePath, remote, branch, runGit2) => {
+  try {
+    await runGit2(worktreePath, ["remote", "get-url", remote]);
+  } catch (e) {
+    return {
+      status: "skipped_no_remote",
+      detail: firstLineFromUnknown(e)
+    };
+  }
+  try {
+    await runGit2(worktreePath, ["push", "-u", remote, branch]);
+    return { status: "pushed" };
+  } catch (e) {
+    return {
+      status: "failed",
+      detail: firstLineFromUnknown(e)
+    };
+  }
+};
+
+// src/run/sync-remote-data-branch.ts
+var SyncRemoteDataBranchMergeError = class extends Error {
+  /** @param message - Human-readable reason (stderr excerpt or generic text). */
+  constructor(message) {
+    super(message);
+    this.name = "SyncRemoteDataBranchMergeError";
+  }
+};
+var remoteTrackingRef = (remote, dataBranch) => `refs/remotes/${remote}/${dataBranch}`;
+var mergeRefSpecifier = (remote, dataBranch) => `${remote}/${dataBranch}`;
+var isLikelyNonFastForwardPushFailure = (detail) => {
+  if (detail === void 0) return false;
+  const d = detail.toLowerCase();
+  return d.includes("non-fast-forward") || d.includes("failed to push");
+};
+var classifyMergeOutput = (combined) => {
+  const c = combined.toLowerCase();
+  if (c.includes("already up to date")) {
+    return "up_to_date";
+  }
+  if (c.includes("fast-forward")) {
+    return "fast_forward";
+  }
+  return "merge_commit";
+};
+var refExists = async (cwd, ref, runGit2) => {
+  try {
+    await runGit2(cwd, ["show-ref", "--verify", "--quiet", ref]);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var fetchRemoteDataBranch = async (worktreePath, remote, dataBranch, runGit2) => {
+  try {
+    await runGit2(worktreePath, ["remote", "get-url", remote]);
+  } catch {
+    return "skipped_no_remote";
+  }
+  try {
+    await runGit2(worktreePath, ["fetch", remote, dataBranch]);
+    return "ok";
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (/couldn't find remote ref|could not find remote ref/i.test(msg)) {
+      return "remote_branch_absent";
+    }
+    throw e;
+  }
+};
+var mergeRemoteTrackingIntoHead = async (worktreePath, remote, dataBranch, runGit2, authorEnv = env) => {
+  const spec = mergeRefSpecifier(remote, dataBranch);
+  const { name, email } = await resolveEffectiveGitAuthorForDataCommit(
+    worktreePath,
+    runGit2,
+    authorEnv
+  );
+  try {
+    const { stdout, stderr } = await runGit2(worktreePath, [
+      "-c",
+      `user.name=${name}`,
+      "-c",
+      `user.email=${email}`,
+      "merge",
+      "--no-edit",
+      spec
+    ]);
+    return classifyMergeOutput(`${stdout}
+${stderr}`);
+  } catch (e) {
+    await runGit2(worktreePath, ["merge", "--abort"]).catch(() => {
+    });
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new SyncRemoteDataBranchMergeError(
+      msg.toLowerCase().includes("conflict") ? "Merge conflict while syncing hyper-pm data branch; merge aborted. Resolve manually on the data branch if needed." : `git merge failed: ${msg.trim().split("\n")[0] ?? msg}`
+    );
+  }
+};
+var runRemoteDataBranchGitSync = async (worktreePath, remote, dataBranch, runGit2, skipPush, deps = {}) => {
+  const tryPushFn = deps.tryPush ?? tryPushDataBranchToRemote;
+  const maxPushAttempts = deps.maxPushAttempts ?? 3;
+  const authorEnv = deps.authorEnv ?? env;
+  let dataBranchFetch = await fetchRemoteDataBranch(worktreePath, remote, dataBranch, runGit2);
+  let dataBranchMerge = dataBranchFetch === "skipped_no_remote" ? "skipped_no_remote" : dataBranchFetch === "remote_branch_absent" ? "skipped_missing_remote_branch" : "up_to_date";
+  if (dataBranchFetch === "ok") {
+    const tracking = remoteTrackingRef(remote, dataBranch);
+    const exists = await refExists(worktreePath, tracking, runGit2);
+    if (!exists) {
+      dataBranchMerge = "skipped_missing_remote_branch";
+    } else {
+      dataBranchMerge = await mergeRemoteTrackingIntoHead(
+        worktreePath,
+        remote,
+        dataBranch,
+        runGit2,
+        authorEnv
+      );
+    }
+  }
+  if (skipPush) {
+    return {
+      dataBranchFetch,
+      dataBranchMerge,
+      dataBranchPush: "skipped_cli",
+      dataBranchPushDetail: "skip-push",
+      pushAttempts: 0
+    };
+  }
+  let pushAttempts = 0;
+  let lastPush = { status: "skipped_no_remote" };
+  const refetchAndMerge = async () => {
+    dataBranchFetch = await fetchRemoteDataBranch(
+      worktreePath,
+      remote,
+      dataBranch,
+      runGit2
+    );
+    if (dataBranchFetch !== "ok") {
+      return;
+    }
+    const tracking = remoteTrackingRef(remote, dataBranch);
+    const exists = await refExists(worktreePath, tracking, runGit2);
+    if (!exists) {
+      return;
+    }
+    dataBranchMerge = await mergeRemoteTrackingIntoHead(
+      worktreePath,
+      remote,
+      dataBranch,
+      runGit2,
+      authorEnv
+    );
+  };
+  for (let attempt = 1; attempt <= maxPushAttempts; attempt += 1) {
+    pushAttempts = attempt;
+    lastPush = await tryPushFn(worktreePath, remote, dataBranch, runGit2);
+    if (lastPush.status === "pushed" || lastPush.status === "skipped_no_remote") {
+      break;
+    }
+    if (lastPush.status === "failed" && isLikelyNonFastForwardPushFailure(lastPush.detail) && attempt < maxPushAttempts) {
+      await refetchAndMerge();
+      continue;
+    }
+    break;
+  }
+  return {
+    dataBranchFetch,
+    dataBranchMerge,
+    dataBranchPush: lastPush.status,
+    ...lastPush.detail !== void 0 ? { dataBranchPushDetail: lastPush.detail } : {},
+    pushAttempts
+  };
 };
 
 // src/storage/append-event.ts
@@ -13576,6 +13985,12 @@ var applyTicketPlanningFieldsFromCreatePayload = (row, payload) => {
   if (typeof tf === "string") {
     row.targetFinishAt = tf;
   }
+  if (Object.prototype.hasOwnProperty.call(payload, "dependsOn")) {
+    const v = parseTicketDependsOnFromPayloadValue(payload["dependsOn"]);
+    if (v !== void 0 && v.length > 0) {
+      row.dependsOn = v;
+    }
+  }
 };
 var applyTicketPlanningFieldsFromUpdatePayload = (row, payload) => {
   if (Object.prototype.hasOwnProperty.call(payload, "labels")) {
@@ -13622,6 +14037,20 @@ var applyTicketPlanningFieldsFromUpdatePayload = (row, payload) => {
   } else if (typeof tf === "string") {
     row.targetFinishAt = tf;
   }
+  if (Object.prototype.hasOwnProperty.call(payload, "dependsOn")) {
+    if (payload["dependsOn"] === null) {
+      delete row.dependsOn;
+    } else {
+      const v = parseTicketDependsOnFromPayloadValue(payload["dependsOn"]);
+      if (v !== void 0) {
+        if (v.length === 0) {
+          delete row.dependsOn;
+        } else {
+          row.dependsOn = v;
+        }
+      }
+    }
+  }
 };
 var applyCreatedAudit = (row, evt) => {
   row.createdAt = evt.ts;
@@ -14248,6 +14677,19 @@ var runGithubInboundSync = async (params) => {
     const planningSource = inboundTicketPlanningPayloadFromFenceMeta(meta);
     const planningPayload = {};
     for (const [k, v] of Object.entries(planningSource)) {
+      if (k === "dependsOn") {
+        if (v === null) {
+          if (!ticketDependsOnListsEqual(ticket.dependsOn, [])) {
+            planningPayload["dependsOn"] = null;
+          }
+        } else if (Array.isArray(v)) {
+          const parsed = parseTicketDependsOnFromPayloadValue(v);
+          if (parsed !== void 0 && !ticketDependsOnListsEqual(ticket.dependsOn, parsed)) {
+            planningPayload["dependsOn"] = parsed;
+          }
+        }
+        continue;
+      }
       const tk = k;
       const cur = ticket[tk];
       if (v === null) {
@@ -14585,6 +15027,9 @@ var buildTicketListQueryFromReadListOpts = (o, deps) => {
   if (targetFinishBeforeMs !== void 0) {
     query.targetFinishBeforeMs = targetFinishBeforeMs;
   }
+  if (o.dependsOn !== void 0 && o.dependsOn.trim() !== "") {
+    query.dependsOnIncludesId = o.dependsOn.trim();
+  }
   return Object.keys(query).length > 0 ? query : void 0;
 };
 var runCli = async (argv, deps = {
@@ -14808,6 +15253,11 @@ var runCli = async (argv, deps = {
     "planning label (repeatable)",
     (value, previous) => [...previous, value],
     []
+  ).option(
+    "--depends-on <id>",
+    "prerequisite ticket id (repeatable)",
+    (value, previous) => [...previous, value],
+    []
   ).option("--priority <p>", "low|medium|high|urgent").option("--size <s>", "xs|s|m|l|xl").option("--estimate <n>", "non-negative estimate (e.g. story points)").option("--start-at <iso>", "planned start work at (ISO-8601)").option("--target-finish-at <iso>", "planned target finish at (ISO-8601)").option("--ai-draft", "draft body via AI (explicit)", false).action(async function() {
     const g = readGlobals(this);
     const o = this.opts();
@@ -14870,6 +15320,10 @@ var runCli = async (argv, deps = {
       "--target-finish-at",
       deps
     );
+    const dependsOnTokensCreate = normalizeCliStringList(o.dependsOn);
+    const dependsOnNormCreate = normalizeTicketDependsOnIds(
+      dependsOnTokensCreate
+    );
     const planningPayload = {
       ...labelsPayloadCreate,
       ...priorityParsed !== void 0 ? { priority: priorityParsed } : {},
@@ -14896,6 +15350,15 @@ var runCli = async (argv, deps = {
       const branchTokens = normalizeCliStringList(o.branch);
       const branchesNorm = normalizeTicketBranchListFromStrings(branchTokens);
       const branchesPayload = branchesNorm.length > 0 ? { branches: branchesNorm } : {};
+      const dependsOnErr = validateTicketDependsOnForWrite({
+        projection: proj,
+        fromTicketId: id,
+        nextDependsOn: dependsOnNormCreate
+      });
+      if (dependsOnErr !== void 0) {
+        throw new Error(dependsOnErr);
+      }
+      const dependsOnPayloadCreate = dependsOnNormCreate.length > 0 ? { dependsOn: dependsOnNormCreate } : {};
       const evt = makeEvent(
         "TicketCreated",
         {
@@ -14906,6 +15369,7 @@ var runCli = async (argv, deps = {
           ...status !== void 0 ? { status } : {},
           ...assigneeCreate,
           ...branchesPayload,
+          ...dependsOnPayloadCreate,
           ...planningPayload
         },
         deps.clock,
@@ -14963,6 +15427,9 @@ var runCli = async (argv, deps = {
   ).option(
     "--branch <name>",
     "when listing (no --id): only tickets linked to this branch (normalized exact match)"
+  ).option(
+    "--depends-on <id>",
+    "when listing (no --id): only tickets that list this ticket id in dependsOn"
   ).option(
     "--priority <p>",
     "when listing (no --id): OR-set of priorities (repeat flag); low|medium|high|urgent",
@@ -15042,7 +15509,17 @@ var runCli = async (argv, deps = {
     "--clear-labels",
     "remove all planning labels from the ticket",
     false
-  ).option("--priority <p>", "low|medium|high|urgent").option("--clear-priority", "remove priority", false).option("--size <s>", "xs|s|m|l|xl").option("--clear-size", "remove size", false).option("--estimate <n>", "non-negative estimate (e.g. story points)").option("--clear-estimate", "remove estimate", false).option("--start-at <iso>", "planned start work at (ISO-8601)").option("--clear-start-at", "remove start work date", false).option("--target-finish-at <iso>", "planned target finish at (ISO-8601)").option("--clear-target-finish-at", "remove target finish date", false).option("--ai-improve", "expand description via AI (explicit)", false).action(async function() {
+  ).option(
+    "--add-depends-on <id>",
+    "add a prerequisite ticket id (repeatable)",
+    (value, previous) => [...previous, value],
+    []
+  ).option(
+    "--remove-depends-on <id>",
+    "remove a prerequisite ticket id (repeatable)",
+    (value, previous) => [...previous, value],
+    []
+  ).option("--clear-depends-on", "remove all ticket dependencies", false).option("--priority <p>", "low|medium|high|urgent").option("--clear-priority", "remove priority", false).option("--size <s>", "xs|s|m|l|xl").option("--clear-size", "remove size", false).option("--estimate <n>", "non-negative estimate (e.g. story points)").option("--clear-estimate", "remove estimate", false).option("--start-at <iso>", "planned start work at (ISO-8601)").option("--clear-start-at", "remove start work date", false).option("--target-finish-at <iso>", "planned target finish at (ISO-8601)").option("--clear-target-finish-at", "remove target finish date", false).option("--ai-improve", "expand description via AI (explicit)", false).action(async function() {
     const g = readGlobals(this);
     const o = this.opts();
     let body = o.body;
@@ -15094,6 +15571,14 @@ ${body}`
       );
       deps.exit(ExitCode.UserError);
     }
+    const addDependsOnTokens = normalizeCliStringList(o.addDependsOn);
+    const removeDependsOnTokens = normalizeCliStringList(o.removeDependsOn);
+    if (o.clearDependsOn === true && (addDependsOnTokens.length > 0 || removeDependsOnTokens.length > 0)) {
+      deps.error(
+        "Cannot use --clear-depends-on with --add-depends-on or --remove-depends-on"
+      );
+      deps.exit(ExitCode.UserError);
+    }
     const mutual = (clear, set, clearName, setName) => {
       if (clear === true && set !== void 0 && set !== "") {
         deps.error(`Cannot use ${clearName} and ${setName} together`);
@@ -15226,6 +15711,35 @@ ${body}`
           payload["labels"] = nextLabels;
         }
       }
+      const wantsDependsOnChange = o.clearDependsOn === true || addDependsOnTokens.length > 0 || removeDependsOnTokens.length > 0;
+      if (wantsDependsOnChange) {
+        let nextDepends;
+        if (o.clearDependsOn === true) {
+          nextDepends = [];
+        } else {
+          const removeDepSet = new Set(
+            normalizeTicketDependsOnIds(removeDependsOnTokens)
+          );
+          nextDepends = normalizeTicketDependsOnIds(
+            (curTicket.dependsOn ?? []).filter((d) => !removeDepSet.has(d))
+          );
+          nextDepends = normalizeTicketDependsOnIds([
+            ...nextDepends,
+            ...addDependsOnTokens
+          ]);
+        }
+        const depErr = validateTicketDependsOnForWrite({
+          projection: proj,
+          fromTicketId: o.id,
+          nextDependsOn: nextDepends
+        });
+        if (depErr !== void 0) {
+          throw new Error(depErr);
+        }
+        if (!ticketDependsOnListsEqual(curTicket.dependsOn, nextDepends)) {
+          payload["dependsOn"] = nextDepends;
+        }
+      }
       if (priorityUpdate !== void 0) {
         payload["priority"] = priorityUpdate;
       }
@@ -15539,94 +16053,192 @@ ${body}`
     }
     deps.exit(ExitCode.Success);
   });
-  program2.command("sync").description("GitHub Issues sync").option("--no-github", "skip network sync", false).action(async function() {
+  program2.command("sync").description("Sync data branch over git; optional GitHub Issues sync").option(
+    "--skip-network",
+    "skip all sync network operations (git fetch/merge/push and GitHub); legacy: --no-github",
+    false
+  ).option(
+    "--with-github",
+    "also run GitHub Issues sync (requires GITHUB_TOKEN or gh; needs sync not off in config)",
+    false
+  ).option(
+    "--git-data",
+    "legacy no-op: default sync already updates the data branch via git only",
+    false
+  ).option(
+    "--skip-push",
+    "after a successful sync, do not push the data branch to the remote",
+    false
+  ).action(async function() {
     const g = readGlobals(this);
     const o = this.opts();
     const repoRoot = await resolveRepoRoot(g.repo);
     const cfg = await loadMergedConfig(repoRoot, g);
-    if (cfg.sync === "off" || o.noGithub) {
+    if (o.withGithub && o.skipNetwork) {
+      deps.error("Cannot use --with-github together with --skip-network");
+      deps.exit(ExitCode.UserError);
+    }
+    if (o.skipNetwork) {
       deps.log(formatOutput(g.format, { ok: true, skipped: true }));
       deps.exit(ExitCode.Success);
     }
-    const githubToken = await resolveGithubTokenForSync({
-      envToken: env.GITHUB_TOKEN,
-      cwd: repoRoot
-    });
-    if (!githubToken) {
-      deps.error(
-        "GitHub auth required for sync: set GITHUB_TOKEN or run `gh auth login`"
-      );
-      deps.exit(ExitCode.EnvironmentAuth);
+    if (o.withGithub) {
+      if (cfg.sync === "off") {
+        deps.error(
+          "GitHub Issues sync is off in config (sync: off). Omit --with-github to sync the data branch via git only, or set sync to outbound/full."
+        );
+        deps.exit(ExitCode.UserError);
+      }
+      const githubToken = await resolveGithubTokenForSync({
+        envToken: env.GITHUB_TOKEN,
+        cwd: repoRoot
+      });
+      if (!githubToken) {
+        deps.error(
+          "GitHub auth required for sync --with-github: set GITHUB_TOKEN or run `gh auth login`"
+        );
+        deps.exit(ExitCode.EnvironmentAuth);
+      }
+      const tmpBase = g.tempDir ?? env.TMPDIR ?? (0, import_node_os2.tmpdir)();
+      const session = await openDataBranchWorktree({
+        repoRoot,
+        dataBranch: cfg.dataBranch,
+        tmpBase,
+        keepWorktree: g.keepWorktree,
+        runGit
+      });
+      try {
+        const projection = await loadProjectionFromDataRoot(
+          session.worktreePath
+        );
+        const gitDerivedSlug = await tryReadGithubOwnerRepoSlugFromGit({
+          repoRoot,
+          remote: cfg.remote,
+          runGit
+        });
+        const { owner, repo: repo2 } = resolveGithubRepo(
+          cfg,
+          env.GITHUB_REPO,
+          gitDerivedSlug
+        );
+        const octokit = new Octokit2({ auth: githubToken });
+        const outboundActor = await resolveGithubTokenActor(octokit);
+        const depsGh = {
+          octokit,
+          owner,
+          repo: repo2,
+          clock: deps.clock,
+          outboundActor
+        };
+        await runGithubOutboundSync({
+          dataRoot: session.worktreePath,
+          projection,
+          config: cfg,
+          deps: depsGh
+        });
+        await runGithubInboundSync({
+          dataRoot: session.worktreePath,
+          projection,
+          config: cfg,
+          deps: depsGh
+        });
+        const projectionAfterInbound = await loadProjectionFromDataRoot(
+          session.worktreePath
+        );
+        await runGithubPrActivitySync({
+          projection: projectionAfterInbound,
+          config: cfg,
+          deps: defaultGithubPrActivitySyncDeps({
+            dataRoot: session.worktreePath,
+            clock: deps.clock,
+            octokit,
+            owner,
+            repo: repo2,
+            actor: outboundActor
+          })
+        });
+        await commitDataWorktreeIfNeeded(
+          session.worktreePath,
+          formatDataBranchCommitMessage("hyper-pm: sync", outboundActor),
+          runGit
+        );
+        let dataBranchPush;
+        let dataBranchPushDetail;
+        if (o.skipPush) {
+          dataBranchPush = "skipped_cli";
+          dataBranchPushDetail = "skip-push";
+        } else {
+          const pushResult = await tryPushDataBranchToRemote(
+            session.worktreePath,
+            cfg.remote,
+            cfg.dataBranch,
+            runGit
+          );
+          dataBranchPush = pushResult.status;
+          dataBranchPushDetail = pushResult.detail;
+          if (pushResult.status === "failed" && pushResult.detail) {
+            deps.error(
+              `hyper-pm: data branch not pushed (${cfg.remote}/${cfg.dataBranch}): ${pushResult.detail}`
+            );
+          }
+        }
+        deps.log(
+          formatOutput(g.format, {
+            ok: true,
+            githubSync: true,
+            dataBranchPush,
+            ...dataBranchPushDetail !== void 0 ? { dataBranchPushDetail } : {}
+          })
+        );
+      } catch (e) {
+        deps.error(e instanceof Error ? e.message : String(e));
+        deps.exit(ExitCode.ExternalApi);
+      } finally {
+        await session.dispose();
+      }
+      deps.exit(ExitCode.Success);
     }
-    const tmpBase = g.tempDir ?? env.TMPDIR ?? (0, import_node_os2.tmpdir)();
-    const session = await openDataBranchWorktree({
+    const tmpBaseGit = g.tempDir ?? env.TMPDIR ?? (0, import_node_os2.tmpdir)();
+    const sessionGit = await openDataBranchWorktree({
       repoRoot,
       dataBranch: cfg.dataBranch,
-      tmpBase,
+      tmpBase: tmpBaseGit,
       keepWorktree: g.keepWorktree,
       runGit
     });
     try {
-      const projection = await loadProjectionFromDataRoot(
-        session.worktreePath
-      );
-      const gitDerivedSlug = await tryReadGithubOwnerRepoSlugFromGit({
-        repoRoot,
-        remote: cfg.remote,
-        runGit
-      });
-      const { owner, repo: repo2 } = resolveGithubRepo(
-        cfg,
-        env.GITHUB_REPO,
-        gitDerivedSlug
-      );
-      const octokit = new Octokit2({ auth: githubToken });
-      const outboundActor = await resolveGithubTokenActor(octokit);
-      const depsGh = {
-        octokit,
-        owner,
-        repo: repo2,
-        clock: deps.clock,
-        outboundActor
-      };
-      await runGithubOutboundSync({
-        dataRoot: session.worktreePath,
-        projection,
-        config: cfg,
-        deps: depsGh
-      });
-      await runGithubInboundSync({
-        dataRoot: session.worktreePath,
-        projection,
-        config: cfg,
-        deps: depsGh
-      });
-      const projectionAfterInbound = await loadProjectionFromDataRoot(
-        session.worktreePath
-      );
-      await runGithubPrActivitySync({
-        projection: projectionAfterInbound,
-        config: cfg,
-        deps: defaultGithubPrActivitySyncDeps({
-          dataRoot: session.worktreePath,
-          clock: deps.clock,
-          octokit,
-          owner,
-          repo: repo2,
-          actor: outboundActor
+      let syncResult;
+      try {
+        syncResult = await runRemoteDataBranchGitSync(
+          sessionGit.worktreePath,
+          cfg.remote,
+          cfg.dataBranch,
+          runGit,
+          Boolean(o.skipPush)
+        );
+      } catch (e) {
+        if (e instanceof SyncRemoteDataBranchMergeError) {
+          deps.error(e.message);
+          deps.exit(ExitCode.UserError);
+        }
+        deps.error(e instanceof Error ? e.message : String(e));
+        deps.exit(ExitCode.UserError);
+      }
+      if (syncResult.dataBranchPush === "failed" && syncResult.dataBranchPushDetail !== void 0) {
+        deps.error(
+          `hyper-pm: data branch not pushed (${cfg.remote}/${cfg.dataBranch}): ${syncResult.dataBranchPushDetail}`
+        );
+      }
+      deps.log(
+        formatOutput(g.format, {
+          ok: true,
+          gitDataOnly: true,
+          ...o.gitData ? { legacyGitDataFlag: true } : {},
+          ...syncResult
         })
-      });
-      await commitDataWorktreeIfNeeded(
-        session.worktreePath,
-        formatDataBranchCommitMessage("hyper-pm: sync", outboundActor),
-        runGit
       );
-      deps.log(formatOutput(g.format, { ok: true }));
-    } catch (e) {
-      deps.error(e instanceof Error ? e.message : String(e));
-      deps.exit(ExitCode.ExternalApi);
     } finally {
-      await session.dispose();
+      await sessionGit.dispose();
     }
     deps.exit(ExitCode.Success);
   });
@@ -15792,7 +16404,7 @@ ${body}`
       await session.dispose();
     }
   });
-  await program2.parseAsync(argv, { from: "node" });
+  await program2.parseAsync(normalizeRawCliArgv(argv), { from: "node" });
 };
 var makeEvent = (type, payload, clock, actor) => ({
   schema: 1,