hilos-agent 0.10.1 → 0.11.1

package/README.md

@@ -158,7 +158,16 @@ can never approve or merge hilos work. See the complete contract in
   PR thread is executed, not described. The daemon relays the request to hilos
   with the id of the message that asked; hilos verifies the person's role and
   that their message really asks for it, then acts with the workspace's GitHub
-  App. The daemon never merges on its own judgment and holds no merge rights.
+  App. If GitHub reports a same-repository merge conflict, the daemon keeps the
+  same turn alive: it fetches the base branch, starts a real two-parent merge on
+  the existing PR branch, names the conflicted files to the coding agent,
+  verifies that no unmerged entries or conflict markers remain, and pushes the
+  repaired head for fresh human review. It never opens a replacement PR or
+  silently merges after repair. Fork PRs stop with an explicit writable-branch
+  boundary. The daemon never merges on its own judgment and holds no merge
+  rights. With `gate:true`, this existing-branch repair still pushes so the PR
+  can return for fresh review. It is the only approve-before-push exception;
+  the repaired head remains unmerged and needs a new approval.
 - **Open a PR** (default) — it commits, pushes with *your* `git`/`gh`, opens a PR,
   and posts a report card with the link. Review on the card: **Approve** merges,
   **Reject** closes, **Request changes** re-works.
@@ -396,6 +405,16 @@ hilos's GitHub App only for workspace owners/admins). Want a human checkpoint
 before anything is pushed? Set `"gate": true`. Keep your token in the config file
 or `HILOS_TOKEN`, never in shared shell history.
 
+### Durable activity, not raw output
+
+On a current hilos server, daemon-launched Claude Code, Codex, Cursor, and
+OpenCode repo runs automatically keep the same bounded activity facts used by
+the live card—phases, tool/file activity, notes, reported usage, and completion—
+in hilos's runtime-neutral event record. Writes are batched, retry-safe,
+bounded to two one-second attempts, re-authorized and redacted on the server,
+and never allowed to fail the coding run. Raw stdout is not sent by this path.
+An older server simply leaves it off.
+
 ### Run transcripts are opt-in
 
 The room gets what a teammate needs to see: a plan, live progress, a report, a
@@ -426,3 +445,13 @@ restart — and **deleting** the key counts as off, not as "leave it as it was".
 
 Env: `HILOS_TOKEN`, `HILOS_URL`, `HILOS_CHANNEL`, `CODING_CMD`, `HILOS_ONCE=1`,
 `HILOS_BACKFILL=1`, `HILOS_UPLOAD_TRANSCRIPTS=1|0`.
+
+## Releasing
+
+Bump `version` in `package.json`, merge, then tag that commit
+`hilos-agent-v<version>` and push the tag. The `npm-publish` workflow checks
+the tag against the tree, parses every source file on Node 20, 22, and 24,
+and publishes to npm (without provenance while the repository is private:
+npm refuses a provenance bundle from a private source repository, 1182).
+`workflow_dispatch` runs the same pipeline as a dry run. Needs the
+`NPM_TOKEN` repository secret (1094).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hilos-agent",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "Run your own coding agent (Claude Code / Codex / Cursor) as an autonomous teammate in a hilos channel. Picks up @mentions in channels and threads, makes the change, and opens a PR for review — your code and credentials never leave your machine. (Approve-before-push is available via gate:true.)",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "homepage": "https://hilos.sh",
   "repository": {

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`;
+}