hilos-agent 0.10.1 → 0.11.2

package/src/conflicts.mjs

@@ -0,0 +1,156 @@
+// 0991 — deterministic Git ownership for local merge-conflict recovery.
+// The coding model edits files; this wrapper creates and validates the merge.
+
+const MAX_NAMED_FILES = 40;
+
+const lines = (value) =>
+  String(value || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+export function validConflictRecovery(value, repoFullName) {
+  if (!value || typeof value !== "object" || value.repairable !== true) return null;
+  const required = ["repoFullName", "prUrl", "branch", "baseBranch", "headSha"];
+  if (required.some((key) => typeof value[key] !== "string" || !value[key].trim())) return null;
+  if (!Number.isInteger(value.prNumber) || value.prNumber <= 0) return null;
+  if (
+    repoFullName &&
+    value.repoFullName.toLowerCase() !== String(repoFullName).toLowerCase()
+  ) {
+    return null;
+  }
+  return {
+    repoFullName: value.repoFullName,
+    prNumber: value.prNumber,
+    prUrl: value.prUrl,
+    branch: value.branch,
+    baseBranch: value.baseBranch,
+    headSha: value.headSha,
+  };
+}
+
+export function conflictRepairBrief(conflict) {
+  return (
+    `Resolve the merge conflicts on existing pull request #${conflict.prNumber} ` +
+    `(${conflict.prUrl}). Preserve the intended work from both \`${conflict.branch}\` and ` +
+    `\`${conflict.baseBranch}\`, run the repository's required verification, and update only ` +
+    `that existing pull request. Do not merge it; return the changed head for fresh human review.`
+  );
+}
+
+export function conflictPromptBlock({ baseBranch, files }) {
+  if (!files.length) {
+    return (
+      `hilos has already merged \`${baseBranch}\` into this pull request branch and Git resolved every file cleanly. ` +
+      "The checkout is still mid-merge so hilos can make the two-parent merge commit after you finish. " +
+      "Run the repository's required verification and make no edits unless verification exposes a real integration problem. Do not run git."
+    );
+  }
+  const named = files.slice(0, MAX_NAMED_FILES);
+  const rest = files.length - named.length;
+  return [
+    `hilos has already started a real merge of \`${baseBranch}\` into this pull request branch. Resolve EVERY conflict by editing the files into the correct combined result. Keep BOTH sides' work unless they are genuinely exclusive; never discard the base branch merely to remove a marker. Regenerate generated files from their sources when the repository provides a generator. Do not run git — hilos owns the merge commit and refuses to push unresolved entries or marker lines.`,
+    ...(named.length ? ["Conflicted files:", ...named.map((file) => `- ${file}`)] : []),
+    ...(rest > 0 ? [`…and ${rest} more.`] : []),
+  ].join("\n");
+}
+
+/** Fetch + start the two-parent merge before the coding model runs. */
+export function startConflictMerge({ git, cwd, conflict }) {
+  const fetched = git(cwd, [
+    "fetch",
+    "origin",
+    `+refs/heads/${conflict.baseBranch}:refs/remotes/origin/${conflict.baseBranch}`,
+  ]);
+  if (fetched.status !== 0) {
+    return {
+      ok: false,
+      reason: `couldn't fetch ${conflict.baseBranch}: ${String(fetched.stderr || "").trim().slice(0, 200)}`,
+    };
+  }
+
+  const merged = git(cwd, [
+    "merge",
+    "--no-commit",
+    "--no-ff",
+    `origin/${conflict.baseBranch}`,
+  ]);
+  const files = lines(git(cwd, ["diff", "--name-only", "--diff-filter=U"]).stdout);
+  if (merged.status !== 0 && files.length === 0) {
+    git(cwd, ["merge", "--abort"]);
+    return {
+      ok: false,
+      reason: `couldn't start the merge: ${String(merged.stderr || "").trim().slice(0, 200)}`,
+    };
+  }
+
+  const mergeHead = git(cwd, ["rev-parse", "-q", "--verify", "MERGE_HEAD"]);
+  if (merged.status === 0 && mergeHead.status !== 0) {
+    return { ok: true, state: "up-to-date", files: [] };
+  }
+  if (mergeHead.status !== 0) {
+    git(cwd, ["merge", "--abort"]);
+    return { ok: false, reason: "Git did not leave a merge to complete." };
+  }
+  return { ok: true, state: files.length ? "conflicts" : "clean", files };
+}
+
+/** Check BEFORE git add: staging clears unmerged index entries. Marker scanning
+ * catches a model that ran git add itself despite the prompt.
+ * @param {{ git: (cwd: string, args: string[]) => { stdout?: string }, cwd: string, knownFiles?: string[] }} args
+ */
+export function remainingConflictFiles({ git, cwd, knownFiles = [] }) {
+  const unmerged = lines(git(cwd, ["diff", "--name-only", "--diff-filter=U"]).stdout);
+  const known = new Set(knownFiles);
+  // The original paths remain unmerged in Git's index until the wrapper stages
+  // the model's edited result. That state alone is expected here; only a NEW
+  // unmerged path (the model started another merge) is structurally unsafe.
+  const unexpectedUnmerged = unmerged.filter((file) => !known.has(file));
+  // With no original conflicts there is nothing useful to scan. Running
+  // `git grep` without pathspecs would inspect the entire repository and could
+  // mistake a deliberate marker example in documentation for this merge's
+  // unresolved work.
+  const markers = knownFiles.length
+    ? lines(
+        git(cwd, [
+          "grep",
+          "-l",
+          "-e",
+          "^<<<<<<< ",
+          "-e",
+          "^>>>>>>> ",
+          "--",
+          ...knownFiles,
+        ]).stdout,
+      )
+    : [];
+  return [...new Set([...unexpectedUnmerged, ...markers])].sort();
+}
+
+/** A coding CLI may run git despite the prompt. Accept its self-commit only
+ * when Git proves it completed the prepared merge; reject an aborted/reset
+ * merge before anything can be pushed.
+ * @param {{ git: (cwd: string, args: string[]) => { status: number, stdout?: string }, cwd: string, baseBranch: string }} args
+ */
+export function validateConflictMergeState({ git, cwd, baseBranch }) {
+  if (git(cwd, ["rev-parse", "-q", "--verify", "MERGE_HEAD"]).status === 0) {
+    return { ok: true, committedByAgent: false };
+  }
+  const baseIsAncestor =
+    git(cwd, ["merge-base", "--is-ancestor", `origin/${baseBranch}`, "HEAD"]).status === 0;
+  const parents = lines(git(cwd, ["rev-list", "--parents", "-n", "1", "HEAD"]).stdout)[0]
+    ?.split(/\s+/)
+    .filter(Boolean) ?? [];
+  if (baseIsAncestor && parents.length >= 3) {
+    return { ok: true, committedByAgent: true };
+  }
+  return {
+    ok: false,
+    reason: `the prepared merge of ${baseBranch} was aborted or replaced before verification`,
+  };
+}
+
+export function conflictCommitTitle(baseBranch) {
+  return `Merge ${baseBranch}: resolve conflicts`;
+}

package/src/cursor-store.mjs

@@ -7,10 +7,9 @@
 // restart resumes from it — bounded by `catchupMs`, because replaying a week of
 // stale asks after a vacation would be worse than skipping them.
 //
-// Telegram semantics, deliberately: persisting the cursor acknowledges
-// DELIVERY into the daemon's queue, not completion of the work. A crash after
-// enqueue can still lose an in-flight task (exactly as today); what can no
-// longer happen is a mention arriving into a dead daemon and never being seen.
+// Persisting the cursor acknowledges a safely completed queue lifecycle, not
+// delivery into volatile memory. New servers add the mention-table ingestion
+// sequence, so edits/rebuilds and equal-timestamp siblings cannot be skipped.
 //
 // Dependency-free and injectable-dir like hook.mjs's state store, so tests run
 // against a temp dir and never touch a real ~/.hilos.
@@ -38,6 +37,13 @@ export function cursorPath(agentId, dir = CURSOR_STATE_DIR) {
  * @returns {string|null} ISO timestamp
  */
 export function loadMentionCursor(agentId, { catchupMs = 0, dir = CURSOR_STATE_DIR, now = Date.now } = {}) {
+  return loadMentionCursorState(agentId, { catchupMs, dir, now })?.createdAt ?? null;
+}
+
+export function loadMentionCursorState(
+  agentId,
+  { catchupMs = 0, dir = CURSOR_STATE_DIR, now = Date.now } = {},
+) {
   if (!agentId || !(catchupMs > 0)) return null;
   let parsed;
   try {
@@ -50,7 +56,24 @@ export function loadMentionCursor(agentId, { catchupMs = 0, dir = CURSOR_STATE_D
   const at = new Date(value).getTime();
   if (Number.isNaN(at)) return null;
   const floor = now() - catchupMs;
-  return at < floor ? new Date(floor).toISOString() : value;
+  const mentionSeq = Number.isSafeInteger(parsed.mentionCursorSeq) && parsed.mentionCursorSeq >= 0
+    ? parsed.mentionCursorSeq
+    : null;
+  if (mentionSeq != null) {
+    // Sequence progress belongs to the ingestion checkpoint, not to the
+    // original message timestamp: editing a year-old message creates fresh
+    // sequence work. New state records when the checkpoint was written so the
+    // catch-up window still bounds genuinely abandoned daemons. Pre-release
+    // sequence files without this additive field remain usable.
+    if (typeof parsed.mentionCursorSavedAt === "string") {
+      const savedAt = new Date(parsed.mentionCursorSavedAt).getTime();
+      if (!Number.isFinite(savedAt)) return null;
+      if (savedAt < floor) return { createdAt: new Date(floor).toISOString(), mentionSeq: null };
+    }
+    return { createdAt: value, mentionSeq };
+  }
+  if (at < floor) return { createdAt: new Date(floor).toISOString(), mentionSeq: null };
+  return { createdAt: value, mentionSeq: null };
 }
 
 /**
@@ -60,14 +83,26 @@ export function loadMentionCursor(agentId, { catchupMs = 0, dir = CURSOR_STATE_D
  *
  * @param {string} agentId
  * @param {string} isoTimestamp
- * @param {{ dir?: string, log?: { error?: (m: string) => void } }} [opts]
+ * @param {{ dir?: string, log?: { error?: (m: string) => void }, mentionSeq?: number|null, now?: () => number }} [opts]
  * @returns {boolean} whether the write landed
  */
-export function saveMentionCursor(agentId, isoTimestamp, { dir = CURSOR_STATE_DIR, log } = {}) {
+export function saveMentionCursor(
+  agentId,
+  isoTimestamp,
+  { dir = CURSOR_STATE_DIR, log, mentionSeq = null, now = Date.now } = {},
+) {
   if (!agentId || typeof isoTimestamp !== "string" || !isoTimestamp) return false;
   try {
     mkdirSync(dir, { recursive: true });
-    writeFileSync(cursorPath(agentId, dir), JSON.stringify({ mentionCursor: isoTimestamp }));
+    writeFileSync(
+      cursorPath(agentId, dir),
+      JSON.stringify({
+        mentionCursor: isoTimestamp,
+        ...(Number.isSafeInteger(mentionSeq) && mentionSeq >= 0
+          ? { mentionCursorSeq: mentionSeq, mentionCursorSavedAt: new Date(now()).toISOString() }
+          : {}),
+      }),
+    );
     return true;
   } catch (e) {
     log?.error?.(`mention cursor not persisted: ${e?.message || e}`);