@nanocollective/roster 0.1.0-alpha.41 → 0.1.0-alpha.43

package/dist/cli.js

@@ -5356,11 +5356,56 @@ async function act(req) {
     if (!flag) throw new Error(`unknown merge method "${req.mergeMethod}"`);
     const args = ["pr", "merge", n, "--repo", repo, flag];
     if (req.body?.trim() && how !== "rebase") args.push("--body", req.body.trim());
-    await run3("gh", args, { encoding: "utf8" });
+    try {
+      await run3("gh", args, { encoding: "utf8" });
+    } catch (err) {
+      throw new Error(whyNotMerged(errText(err), await prState(repo, n)));
+    }
     return { ok: true, action, mergedBy: how };
   }
   throw new Error(`unknown action "${action}"`);
 }
+function whyNotMerged(ghError, pr) {
+  const checks = pr?.statusCheckRollup ?? [];
+  const name = (c) => c.name || c.context || "a check";
+  const running = checks.filter(
+    (c) => c.status && c.status !== "COMPLETED" || c.state === "PENDING" || c.state === "EXPECTED"
+  );
+  const failing = checks.filter(
+    (c) => ["FAILURE", "TIMED_OUT", "CANCELLED", "ACTION_REQUIRED", "ERROR"].includes(
+      String(c.conclusion || c.state || "")
+    )
+  );
+  const list = (cs) => cs.map(name).join(", ");
+  if (pr?.mergeStateStatus === "BLOCKED" && failing.length)
+    return `Not merged: checks failed (${list(failing)}).`;
+  if (pr?.mergeStateStatus === "BLOCKED" && running.length)
+    return `Not merged: checks are still running (${list(running)}). Merge again once they pass.`;
+  if (pr?.mergeStateStatus === "BLOCKED")
+    return "Not merged: the branch rules require something first, such as a review. Open it in GitHub to see what.";
+  if (pr?.mergeStateStatus === "BEHIND")
+    return "Not merged: the branch is behind its base, and the branch rules require it to be up to date.";
+  if (pr?.mergeStateStatus === "DIRTY") return "Not merged: the branch conflicts with its base.";
+  const line = ghError.split("\n").map((l) => l.replace(/^[!X✗]\s*/, "").trim()).find((l) => l && !l.startsWith("Command failed") && !/--auto|--admin/.test(l));
+  return `Not merged: ${line ?? "GitHub refused it without saying why."}`;
+}
+function errText(err) {
+  const e = err;
+  return `${e?.stderr ?? ""}
+${e?.message ?? ""}`;
+}
+async function prState(repo, n) {
+  try {
+    const { stdout } = await run3(
+      "gh",
+      ["pr", "view", n, "--repo", repo, "--json", "mergeStateStatus,statusCheckRollup"],
+      { encoding: "utf8" }
+    );
+    return JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+}
 async function mergeMethodFor(repo) {
   try {
     const { stdout } = await run3(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanocollective/roster",
-  "version": "0.1.0-alpha.41",
+  "version": "0.1.0-alpha.43",
   "description": "An agent-run org, powered by GitHub. Scaffold AI staff members whose brain is a repo.",
   "type": "module",
   "bin": {
@@ -16,6 +16,23 @@
   "engines": {
     "node": ">=20"
   },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --target node20 --clean",
+    "dev": "tsx src/cli.ts",
+    "test": "tsx --test test/*.test.ts",
+    "test:all": "pnpm test:format && pnpm test:lint && pnpm test:types && pnpm test:knip && pnpm test",
+    "test:ava:coverage": "c8 --reporter=text --reporter=json-summary tsx --test test/*.test.ts",
+    "test:format": "biome check --no-errors-on-unmatched .",
+    "test:lint": "biome lint .",
+    "test:lint:fix": "biome check --write .",
+    "test:types": "tsc --noEmit",
+    "test:knip": "knip",
+    "test:audit": "pnpm audit --audit-level=high",
+    "test:security": "semgrep scan --config auto --error",
+    "typecheck": "tsc --noEmit",
+    "format": "biome check --write .",
+    "prepublishOnly": "pnpm test:all && pnpm build"
+  },
   "devDependencies": {
     "@biomejs/biome": "^2.5.12",
     "@types/node": "^22.10.2",
@@ -35,24 +52,9 @@
     "url": "https://github.com/Nano-Collective/roster/issues"
   },
   "author": "Nano Collective",
+  "packageManager": "pnpm@11.0.9",
   "publishConfig": {
     "access": "public",
     "tag": "latest"
-  },
-  "scripts": {
-    "build": "tsup src/cli.ts --format esm --target node20 --clean",
-    "dev": "tsx src/cli.ts",
-    "test": "tsx --test test/*.test.ts",
-    "test:all": "pnpm test:format && pnpm test:lint && pnpm test:types && pnpm test:knip && pnpm test",
-    "test:ava:coverage": "c8 --reporter=text --reporter=json-summary tsx --test test/*.test.ts",
-    "test:format": "biome check --no-errors-on-unmatched .",
-    "test:lint": "biome lint .",
-    "test:lint:fix": "biome check --write .",
-    "test:types": "tsc --noEmit",
-    "test:knip": "knip",
-    "test:audit": "pnpm audit --audit-level=high",
-    "test:security": "semgrep scan --config auto --error",
-    "typecheck": "tsc --noEmit",
-    "format": "biome check --write ."
   }
-}
+}

package/templates/ops/.github/workflows/session.yaml

@@ -79,6 +79,14 @@ jobs:
     # secrets are not usable in a step-level `if`, so the presence check is hoisted here.
     env:
       HAS_PUBLIC_APP: ${{ secrets.PUBLIC_APP_ID != '' }}
+      # Nothing is listening once the agent ends its turn: the session is over and a background
+      # job dies with the runner. Claude Code moves any command past its timeout (ten minutes by
+      # default) into the background, and an agent told "you will be notified" ends its turn to
+      # wait, so a slow test suite cost the whole run, unpushed, reported as a success. With
+      # background tasks off a slow command stays in the foreground, and the higher cap lets a
+      # long gate finish inside the turn. timeout-minutes is still the real bound.
+      CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1"
+      BASH_MAX_TIMEOUT_MS: "2700000"
 
     steps:
       # For the run record at the end. A job has no start time of its own to read back.
@@ -341,6 +349,37 @@ jobs:
           fi
           eval "$RUN"
 
+      # A session can exit cleanly without doing what it was asked: the success above only means
+      # the agent stopped. A mention is answered by a reply in its thread, or by the issue being
+      # closed when the request said to answer somewhere else. When neither happened the job
+      # fails, so the notice below tells the human instead of leaving them waiting.
+      #
+      # Never fails on its own account: if the issue cannot be read, nothing is claimed.
+      - name: Check the request was answered
+        id: answered
+        if: >-
+          inputs.kind == 'mention' && inputs.issue_number != ''
+          && (steps.session_action.outcome == 'success' || steps.session_cli.outcome == 'success')
+        env:
+          GH_TOKEN: ${{ steps.private.outputs.token }}
+          BOT: ${{ steps.private.outputs.app-slug }}[bot]
+          ISSUE: ${{ inputs.issue_number }}
+        run: |
+          set -uo pipefail
+          since=$(date -u -d "@$ROSTER_STARTED" +%Y-%m-%dT%H:%M:%SZ)
+          if ! state=$(gh api "repos/${{ github.repository }}/issues/$ISSUE" --jq .state) ||
+             ! replies=$(gh api --paginate "repos/${{ github.repository }}/issues/$ISSUE/comments?since=$since" \
+               --jq ".[] | select(.user.login == \"$BOT\" and .created_at >= \"$since\") | .id"); then
+            echo "::warning::could not read #$ISSUE, so whether it was answered is unknown"
+            exit 0
+          fi
+          if [ "$state" = "closed" ] || [ -n "$replies" ]; then
+            exit 0
+          fi
+          echo "unanswered=true" >> "$GITHUB_OUTPUT"
+          echo "::error::the session ended without replying on #$ISSUE or closing it"
+          exit 1
+
       # What this run was and what it cost, in the job summary and as an artifact with a stable
       # name, which is what the portal's Runs screen and `roster doctor` read back. Never fatal:
       # a missing record costs a row in a table, and failing the job over it would cost the run.
@@ -354,6 +393,7 @@ jobs:
           MODEL: ${{ steps.agent.outputs.model || inputs.model }}
           AGENT_OUTCOME: ${{ steps.session_action.outcome != 'skipped' && steps.session_action.outcome || steps.session_cli.outcome }}
           JOB_STATUS: ${{ job.status }}
+          UNANSWERED: ${{ steps.answered.outputs.unanswered }}
           RESULT_FILE: ${{ steps.session_action.outputs.execution_file || format('{0}/.roster-run/agent-result.json', github.workspace) }}
         run: node roster-ops/run-record.mjs --out .roster-run/run.json
 
@@ -383,6 +423,7 @@ jobs:
           BRAIN_DIR: ${{ steps.plan.outputs.brain_dir }}
           BRAIN_REPO: ${{ steps.plan.outputs.brain_repo || github.repository }}
           ISSUE: ${{ inputs.issue_number }}
+          UNANSWERED: ${{ steps.answered.outputs.unanswered }}
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         run: |
           set -uo pipefail
@@ -402,6 +443,9 @@ jobs:
           fi
 
           body="This run did not finish, so there is no answer coming. [Run ${GITHUB_RUN_ID}]($RUN_URL) has the error."
+          if [ "$UNANSWERED" = "true" ]; then
+            body="This run stopped without replying here or closing the issue, so there is no answer coming. [Run ${GITHUB_RUN_ID}]($RUN_URL) shows where it stopped."
+          fi
           if [ -n "$APP_TOKEN" ] && GH_TOKEN="$APP_TOKEN" gh issue comment "$issue" --repo "$BRAIN_REPO" --body "$body"; then
             exit 0
           fi

package/templates/ops/org/operating.md

@@ -14,6 +14,10 @@ question instead of doing work has wasted its slot.
   not stand still.
 - **Never end a run blocked.** If everything on the list is genuinely blocked, do the most useful
   unblocked thing you can find and say so in the report.
+- **Finish inside the run.** Once you stop, the run is over: nothing will wake you, and anything
+  left running dies with it. Never end a turn to wait for a command; wait for it in the same call.
+  **Push your branch before a slow check** such as a full test suite, so the work survives if the
+  run is cut short, and push again once it passes.
 
 ## Choosing work
 

package/templates/ops/run-record.mjs

@@ -64,9 +64,11 @@ export function readResult(text) {
  * What happened, in one word.
  *
  * The agent step's own outcome when it ran. When it never ran, the job's status says whether
- * that was a cancel (a timeout is one) or a failure somewhere in the setup before it.
+ * that was a cancel (a timeout is one) or a failure somewhere in the setup before it. A mention
+ * the agent exited from cleanly without answering is not a success, whatever the agent says.
  */
-export function outcomeOf(agentOutcome, jobStatus) {
+export function outcomeOf(agentOutcome, jobStatus, unanswered = false) {
+  if (agentOutcome === "success" && unanswered) return "unanswered";
   if (["success", "failure", "cancelled"].includes(agentOutcome)) return agentOutcome;
   if (jobStatus === "cancelled") return "cancelled";
   return "setup-failure";
@@ -79,7 +81,7 @@ export function buildRecord(env, resultText, now = Date.now()) {
     v: 1,
     staff: env.STAFF ?? "",
     kind: env.KIND ?? "",
-    outcome: outcomeOf(env.AGENT_OUTCOME, env.JOB_STATUS),
+    outcome: outcomeOf(env.AGENT_OUTCOME, env.JOB_STATUS, env.UNANSWERED === "true"),
     started: started ? new Date(started * 1000).toISOString() : null,
     duration_s: started ? Math.max(0, Math.round(now / 1000 - started)) : null,
     agent: env.AGENT_ID || null,

package/templates/portal/js/views/inbox.js

@@ -627,10 +627,11 @@ function inboxScreen(m, opts) {
       status.textContent = msg ?? "";
       status.className = "meta";
     };
+    // busy(false) clears the status line, so it goes first: the other way round wiped the
+    // error as it was written, and a refused merge looked like nothing happening at all.
     const failed = (e) => {
-      status.textContent = e.message;
-      status.className = "meta err";
       busy(false);
+      status.textContent = e.message;
       status.className = "meta err";
     };