@mmerterden/multi-agent-pipeline 17.6.0 → 18.0.0

package/pipeline/scripts/diff-risk-score.mjs

@@ -369,8 +369,9 @@ function main() {
     files: TOP ? rows.slice(0, Number(TOP)) : rows,
   };
 
+  // Returning, not exiting: this payload carries a row per changed file and
+  // process.exit() would cut it at the pipe buffer.
   process.stdout.write(PRETTY ? JSON.stringify(out, null, 2) + "\n" : JSON.stringify(out) + "\n");
-  process.exit(0);
 }
 
 try {

package/pipeline/scripts/doctor.mjs

@@ -53,6 +53,7 @@ import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { runMain } from "../lib/fatal.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const HOME = homedir();
@@ -63,6 +64,12 @@ const JSON_OUT = argv.includes("--json");
 const PROBE = argv.includes("--probe");
 const EXPLAIN = argv.includes("--explain");
 const LIST = argv.includes("--list-checks");
+// `--profile server` adds checks that only matter when nobody is at the
+// keyboard. They are ADDITIVE: the default run is byte-for-byte what it was,
+// because a laptop being told it fails a server check would teach people to
+// ignore doctor.
+const profileFlag = argv.find((a) => a.startsWith("--profile="));
+const PROFILE = profileFlag ? profileFlag.slice("--profile=".length) : "";
 const taskFlag = argv.find((a) => a.startsWith("--task-tools="));
 const TASK_TOOLS = taskFlag ? taskFlag.split("=")[1] : null;
 
@@ -89,6 +96,15 @@ const CHECK_IDS = [
   "worktree-residue",
 ];
 
+// Only under `--profile server`. Kept in their own list so `--list-checks`
+// can say which ones a default run does not include.
+const SERVER_CHECK_IDS = [
+  "unattended-contract",
+  "unattended-permissions",
+  "scheduler",
+  "keychain-unlock",
+];
+
 // Only these six may return BLOCK. Enforced below, not merely documented: a
 // check that returns BLOCK without being listed here is downgraded and the
 // downgrade is reported, because an unenforced rule is a comment.
@@ -782,21 +798,138 @@ function checkWorktreeResidue() {
 
 /* ------------------------------------------------------------------ main -- */
 
+/**
+ * Checks that only matter when nobody is at the keyboard.
+ *
+ * Every one of them is a way a server run stops WITHOUT SAYING SO - the
+ * failure mode this whole profile exists for. A laptop hits none of them
+ * because a human is there to answer, unlock and restart, which is exactly why
+ * they are not in the default run.
+ *
+ * None may BLOCK: `MAY_BLOCK` is a closed set and these are readiness, not
+ * correctness. A machine that fails all four still runs the pipeline fine with
+ * someone watching it.
+ *
+ * @param {{root: string}|any} resolved the install layout from checkInstallPresent
+ */
+function checkServerProfile(resolved) {
+  const root = resolved?.root || join(homedir(), ".claude");
+
+  // 1. The contract exists on this machine. Without it nothing tells the
+  //    operator which entry points honour MULTI_AGENT_UNATTENDED.
+  const contract = join(root, "multi-agent-refs", "unattended-contract.md");
+  if (existsSync(contract)) {
+    ok("unattended-contract");
+  } else {
+    report(
+      "unattended-contract",
+      "WARN",
+      "unattended-contract.md is not installed, so nothing here documents what an unattended run resolves",
+      "run /multi-agent:update to refresh the reference tree",
+    );
+  }
+
+  // 2. The permission posture. autopilot spawns `claude --permission-prompts
+  //    none`, but the tools it then calls still have to be allowed somewhere,
+  //    and on a fresh machine they are not - the run stops at the first
+  //    prompt with nobody to answer it.
+  const settings = join(root, "settings.json");
+  let allow = [];
+  try {
+    allow = JSON.parse(readFileSync(settings, "utf-8"))?.permissions?.allow ?? [];
+  } catch {
+    allow = [];
+  }
+  const needed = ["Bash", "Edit", "Write"];
+  const missing = needed.filter((t) => !allow.some((a) => String(a).startsWith(t)));
+  if (!missing.length) {
+    ok("unattended-permissions");
+  } else {
+    report(
+      "unattended-permissions",
+      "WARN",
+      `permissions.allow does not cover ${missing.join(", ")}; an unattended run stops at the first prompt`,
+      "run /multi-agent:setup, or add them to permissions.allow in settings.json",
+      { settings, allow },
+    );
+  }
+
+  // 3. Something has to start the work. launchd is the only scheduler this
+  //    ships a template for; a server with no agent loaded runs nothing and
+  //    looks idle rather than broken.
+  let loaded = false;
+  try {
+    loaded = execFileSync("launchctl", ["list"], { encoding: "utf-8", timeout: 5000 }).includes(
+      "multi-agent",
+    );
+  } catch {
+    // launchctl absent or refusing: treat as "nothing is loaded", which is the
+    // conservative read - claiming a scheduler we could not see would be worse.
+  }
+  if (loaded) {
+    ok("scheduler");
+  } else {
+    report(
+      "scheduler",
+      "WARN",
+      "no multi-agent launchd agent is loaded, so nothing starts a queued run on its own",
+      "run /multi-agent:autopilot to install the agent, or schedule the runner yourself",
+    );
+  }
+
+  // 4. The keychain. Every credential this pipeline reads lives there, and a
+  //    LaunchDaemon started before login gets a LOCKED keychain: each fetch
+  //    fails, and the failures surface far away as 401s that blame the token.
+  //    Reading a real credential here would be a network call and a side
+  //    effect; the presence of a login-keychain path is the cheap proxy.
+  let keychain = "";
+  try {
+    keychain = execFileSync("security", ["default-keychain"], {
+      encoding: "utf-8",
+      timeout: 5000,
+    }).trim();
+  } catch {
+    // Same shape: unreachable reads as absent.
+  }
+  if (keychain) {
+    ok("keychain-unlock");
+  } else {
+    report(
+      "keychain-unlock",
+      "WARN",
+      "no default keychain is reachable from this session; a boot-time daemon sees a locked one and every credential read fails as a 401",
+      "run the LaunchAgent at login rather than a LaunchDaemon at boot (docs/server-readiness.md)",
+    );
+  }
+}
+
 function main() {
   if (LIST) {
+    // Lists what THIS invocation would run, which is what the name promises
+    // and what the registry gate compares against the output of a real run.
+    // Listing the server checks unconditionally made `--list-checks` disagree
+    // with a default run by four, and the gate that counts printed lines
+    // against listed checks caught it immediately.
     for (const id of CHECK_IDS) process.stdout.write(`${id}\n`);
+    if (PROFILE === "server") for (const id of SERVER_CHECK_IDS) process.stdout.write(`${id}\n`);
     return;
   }
   const unknown = argv.filter(
-    (a) => a.startsWith("--") && !/^--(probe|json|explain|list-checks|task-tools=)/.test(a),
+    (a) =>
+      a.startsWith("--") && !/^--(probe|json|explain|list-checks|task-tools=|profile=)/.test(a),
   );
   if (unknown.length) {
     process.stderr.write(
-      `usage: doctor.mjs [--probe] [--json] [--explain] [--task-tools=yes|no] | --list-checks\n`,
+      `usage: doctor.mjs [--probe] [--json] [--explain] [--task-tools=yes|no] [--profile=server] | --list-checks\n`,
     );
     process.exitCode = 3;
     return;
   }
+  if (PROFILE && PROFILE !== "server") {
+    process.stderr.write(`usage: --profile takes "server" (got "${PROFILE}")\n`);
+    process.exitCode = 3;
+    return;
+  }
   if (taskFlag && TASK_TOOLS !== "yes" && TASK_TOOLS !== "no") {
     process.stderr.write("usage: --task-tools takes yes or no\n");
     process.exitCode = 3;
@@ -837,6 +970,7 @@ function main() {
   checkMcpSurface();
   checkDiskSpace();
   checkWorktreeResidue();
+  if (PROFILE === "server") checkServerProfile(resolved);
 
   const blocked = results.filter((r) => r.severity === "BLOCK");
   const warned = results.filter((r) => r.severity === "WARN");
@@ -852,7 +986,7 @@ function main() {
   // Every check prints, in registry order, including the ones that found
   // nothing and the ones that were not run. A list that shows only problems
   // cannot be told apart from a list that was never produced.
-  for (const id of CHECK_IDS) {
+  for (const id of [...CHECK_IDS, ...SERVER_CHECK_IDS]) {
     const r = results.find((x) => x.id === id);
     if (!r) continue;
     if (r.severity === "OK") {
@@ -897,5 +1031,5 @@ function invokedDirectly() {
 }
 
 if (invokedDirectly()) {
-  main();
+  runMain("doctor", main);
 }

package/pipeline/scripts/evidence-gate.mjs

@@ -35,7 +35,7 @@
 //   1  -  pass claim is UNVERIFIED (no evidence / empty / shows failure / no success marker) -> caller must NOT record passed
 //   2  -  usage error
 
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 
 // Failure markers are kept DEFINITIVE (not broad) because failure now overrides
 // success (see the decision logic): a bare "error:" or stray "FAILED" in an
@@ -103,12 +103,18 @@ function parseArgs(argv) {
   return out;
 }
 
+// Both of these have to stop the run where they are called - the gate's whole
+// contract is "verdict, then nothing else happens" - so process.exit() stays.
+// What changes is the write: console.log to a pipe is asynchronous and exit
+// discards what has not drained, while writeFileSync to fd 1 returns only once
+// the bytes are gone. The verdict is short today; the verdict is also the only
+// thing a caller reads, so losing half of it is the one failure that matters.
 function fail(msg) {
-  console.log(JSON.stringify({ ok: false, code: 1, reason: msg }));
+  writeFileSync(1, `${JSON.stringify({ ok: false, code: 1, reason: msg })}\n`);
   process.exit(1);
 }
 function ok(msg) {
-  console.log(JSON.stringify({ ok: true, code: 0, reason: msg }));
+  writeFileSync(1, `${JSON.stringify({ ok: true, code: 0, reason: msg })}\n`);
   process.exit(0);
 }
 function usage(msg) {

package/pipeline/scripts/feedback-send.mjs

@@ -138,8 +138,10 @@ async function main() {
   };
 
   if (process.argv.includes("--dry-run")) {
+    // return, not process.exit(0): the whole point of --dry-run is to read this
+    // payload, and exiting truncates it whenever stdout is a pipe.
     process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    process.exit(0);
+    return;
   }
 
   if (!endpointAllowed(endpoint)) {
@@ -180,4 +182,12 @@ async function main() {
   }
 }
 
-main();
+// `main()` is async, and calling it bare leaves any rejection it does not
+// handle itself as an unhandled rejection: Node prints its own stack trace and
+// exits 1, so the user of a feedback command sees a crash dump instead of the
+// one line this file writes for every other failure. The catch keeps the
+// failure in this file's own voice.
+main().catch((err) => {
+  process.stderr.write(`ERROR: feedback-send failed  -  ${err?.message ?? err}\n`);
+  process.exit(1);
+});

package/pipeline/scripts/gc-abandoned.sh

@@ -64,7 +64,7 @@
 #
 # Exit: 0 on success (including "nothing to do"), 2 on usage error.
 
-set -uo pipefail
+set -euo pipefail
 
 LOGS="$HOME/.claude/logs/multi-agent"
 REPOS="$HOME"
@@ -121,20 +121,25 @@ HANDLED=""
 # sweep that walks one layout leaves the other copy claiming the run is live.
 while IFS= read -r state; do
   [ -f "$state" ] || continue
-  status=$(jq -r '.status // ""' "$state" 2>/dev/null)
+  # Every jq read in this loop is forgiven. A malformed state file is exactly
+  # what a sweep for abandoned runs expects to meet, and under `set -e` the
+  # first one would end the sweep - leaving every run AFTER it untouched and
+  # reporting a clean tree. An empty value already means "unknown", and the
+  # rules below refuse to delete on unknown.
+  status=$(jq -r '.status // ""' "$state" 2>/dev/null || true)
   # Only runs that CLAIM to be running. A file with no status is unknown, and
   # unknown is not a licence to delete.
   case "$status" in in_progress | paused | awaiting_input) ;; *) continue ;; esac
 
-  task=$(jq -r '.taskId // .jiraId // ""' "$state" 2>/dev/null)
+  task=$(jq -r '.taskId // .jiraId // ""' "$state" 2>/dev/null || true)
   [ -n "$task" ] || continue
-  phase=$(jq -r '.currentPhase // "?"' "$state" 2>/dev/null)
+  phase=$(jq -r '.currentPhase // "?"' "$state" 2>/dev/null || true)
   # `.pr` is an object in the schema and a bare URL string in three state files
   # on disk. `jq '.pr.url'` on a string errors, and with stderr suppressed that
   # reads as "no PR" - so a run whose PR is already open would be classed as dead
   # and reaped. Read the shape, do not assume it.
-  pr=$(jq -r 'if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring' "$state" 2>/dev/null)
-  wt=$(jq -r '.worktreePath // ""' "$state" 2>/dev/null)
+  pr=$(jq -r 'if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring' "$state" 2>/dev/null || true)
+  wt=$(jq -r '.worktreePath // ""' "$state" 2>/dev/null || true)
 
   # Rule 1: waiting for you is not residue.
   if [ "$status" = "awaiting_input" ] || [ -n "$pr" ] || [ "$phase" = "6" ] || [ "$phase" = "7" ]; then
@@ -142,7 +147,8 @@ while IFS= read -r state; do
     continue
   fi
 
-  mtime=$(_mtime "$state")
+  mtime=$(_mtime "$state" || true)
+  [ -n "$mtime" ] || continue
   age_days=$(((NOW - mtime) / 86400))
   if [ "$phase" = "0" ]; then
     limit="$PHASE0_DAYS"; kind="left at a Phase 0 question"
@@ -155,7 +161,8 @@ while IFS= read -r state; do
   # root recorded in worktreePath is the shape that would delete a checkout.
   safe_wt=""
   if [ -n "$wt" ] && [ -d "$wt" ] && [ ! -L "$wt" ]; then
-    real=$(cd "$wt" 2>/dev/null && pwd -P)
+    # A worktree path that no longer resolves is the ordinary case here.
+    real=$(cd "$wt" 2>/dev/null && pwd -P || true)
     case "$real" in
       */.worktrees/*) safe_wt="$real" ;;
       *) skipped_unsafe=$((skipped_unsafe + 1)) ;;
@@ -187,8 +194,11 @@ $safe_wt"
   fi
 
   run_dir=$(dirname "$state")
-  mkdir -p "$run_dir/artifacts" 2>/dev/null
-  cp "$state" "$run_dir/artifacts/agent-state.json" 2>/dev/null
+  # Forgiven, both of them: this is the salvage copy, and a run whose artefacts
+  # cannot be copied is still a run that has to be marked abandoned. Under
+  # `set -e` an unreadable state file here would end the entire sweep.
+  mkdir -p "$run_dir/artifacts" 2>/dev/null || true
+  cp "$state" "$run_dir/artifacts/agent-state.json" 2>/dev/null || true
   tmp="$state.tmp.$$"
   if jq --arg r "abandoned by gc-abandoned after ${age_days}d idle" \
     '.status = "failed" | .haltReason = $r' "$state" > "$tmp" 2>/dev/null; then
@@ -209,7 +219,8 @@ $safe_wt"
   if [ -n "$safe_wt" ]; then
     repo=${safe_wt%%/.worktrees/*}
     git -C "$repo" worktree remove --force "$safe_wt" >/dev/null 2>&1 || rm -rf "$safe_wt"
-    git -C "$repo" worktree prune >/dev/null 2>&1
+    # Forgiven: one flaky prune must not end the sweep before its summary line.
+    git -C "$repo" worktree prune >/dev/null 2>&1 || true
     printf '→ removed: %s (%s, idle %sd)\n' "$task" "$human" "$age_days"
     freed_kb=$((freed_kb + ${size_kb:-0}))
   else
@@ -233,7 +244,11 @@ if [ "$STATE_ONLY" -eq 0 ] && [ -d "$REPOS" ]; then
   # re-walk of the log tree for each of 28 directories.
   index=$(find "$LOGS" -name agent-state.json -type f -maxdepth 4 -not -path '*/artifacts/*' 2>/dev/null |
     while IFS= read -r f; do
-      jq -r '[(.worktreePath // ""), (.taskId // .jiraId // ""), (.status // ""), (if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring), ((.currentPhase // "") | tostring)] | @tsv' "$f" 2>/dev/null
+      # One malformed state file must not truncate the index: under `set -e`
+      # a jq failure inside this subshell ends the loop, and the entries after
+      # it would silently not exist - which reads as "no worktree matches" and
+      # protects nothing.
+      jq -r '[(.worktreePath // ""), (.taskId // .jiraId // ""), (.status // ""), (if (.pr|type)=="string" then .pr elif (.pr|type)=="object" then (.pr.url // .pr.number // "") else "" end | tostring), ((.currentPhase // "") | tostring)] | @tsv' "$f" 2>/dev/null || true
     done)
 
   for wtroot in "$REPOS"/*/.worktrees; do
@@ -322,7 +337,8 @@ if [ "$STATE_ONLY" -eq 0 ] && [ -d "$REPOS" ]; then
         continue
       fi
       git -C "$repo" worktree remove --force "$real" >/dev/null 2>&1 || rm -rf "$real"
-      git -C "$repo" worktree prune >/dev/null 2>&1
+      # Same reason as the first pass: a failed prune is not a reason to stop.
+      git -C "$repo" worktree prune >/dev/null 2>&1 || true
       printf '→ removed worktree: %s (%s, %s, idle %sd)\n' "$id" "$why" "$human" "$age_days"
       freed_kb=$((freed_kb + ${size_kb:-0}))
       removed=$((removed + 1))

package/pipeline/scripts/gc-worktrees.sh

@@ -34,7 +34,7 @@
 #
 # Exit: 0 on success (including "nothing to do"), 2 on usage error.
 
-set -uo pipefail
+set -euo pipefail
 
 REPO="$PWD"
 DELETE=0
@@ -69,7 +69,9 @@ if ! git -C "$REPO" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
   echo "gc-worktrees: $REPO is not a git work tree  -  nothing to do"
   exit 0
 fi
-REPO="$(cd "$REPO" && pwd -P)"
+# A repo path that cannot be entered is a usage error with a message, not a
+# silent exit 1 three lines before the message exists.
+REPO="$(cd "$REPO" && pwd -P)" || { echo "gc-worktrees: cannot enter $REPO" >&2; exit 2; }
 # Anchor on the MAIN worktree (first porcelain entry) so a run started from a
 # subdirectory OR from inside a linked worktree still targets
 # <main-repo>/.worktrees/ rather than a bogus <subdir>/.worktrees/ (which
@@ -107,7 +109,9 @@ EOF
   for d in "$WT_ROOT"/*/; do
     [ -d "$d" ] || continue
     [ -L "${d%/}" ] && continue  # never follow a symlinked entry out of the tree
-    dir="$(cd "$d" && pwd -P)"
+    # A directory that vanished between the glob and this line is ordinary on a
+    # machine where runs are finishing; skipping it is the answer, not aborting.
+    dir="$(cd "$d" && pwd -P)" || continue
     # Path guard: only ever consider dirs strictly inside <repo>/.worktrees/.
     case "$dir" in "$WT_ROOT"/*) ;; *) continue ;; esac
     if printf '%s\n' "$registered" | grep -qxF "$dir"; then
@@ -120,7 +124,10 @@ EOF
   done
 fi
 for dir in ${orphans+"${orphans[@]}"}; do
-  size=$(du -sh "$dir" 2>/dev/null | cut -f1)
+  # Cosmetic: the size goes in a report line and prints as "?" when du cannot
+  # read it. Under `set -e` with pipefail an unreadable directory would end the
+  # sweep instead.
+  size=$(du -sh "$dir" 2>/dev/null | cut -f1 || true)
   if [ "$DELETE" -eq 1 ]; then
     rm -rf "$dir" && { echo "→ removed orphan worktree dir: ${dir#"$REPO"/} (${size:-?})"; changed=$((changed + 1)); }
   else

package/pipeline/scripts/github-ssh-setup.sh

@@ -1,16 +1,60 @@
 #!/bin/bash
 # GitHub SSH Key Oluşturma ve Kurulum Scripti
+#
+# HEADLESS: her soru bir env değişkeniyle önceden cevaplanabilir ve terminal
+# yoksa script SORMAZ. Üç `read -p` koruma olmadan duruyordu; bir launchd
+# ajanının ya da uzak bir kabuğun altında ilki sonsuza kadar bekler ve dışarı
+# hiçbir şey yazmaz, yani kurulum "asılı kaldı" diye görünür. Bir sunucuda
+# çalışması hedeflenen bir aracın sessizce beklemesi, açıkça reddetmesinden
+# kötüdür.
+#
+#   MULTI_AGENT_UNATTENDED=1  terminal olsa bile soru sorulmaz
+#   SSH_SETUP_EMAIL     anahtarın yorum alanına yazılacak e-posta (zorunlu)
+#   SSH_SETUP_OVERWRITE e|h  - var olan anahtarın üzerine yazılsın mı (varsayılan h)
+#   SSH_SETUP_TEST      e|h  - sonunda github.com'a bağlantı denensin mi (varsayılan h)
 
 set -euo pipefail
 
+# Soruyu sor, ama yalnız soracak birisi varsa. Terminal yoksa env'deki cevabı
+# kullan; o da yoksa boş dön ve kararı çağırana bırak.
+ask() {
+    local prompt="$1" preset="$2" __var="$3" reply=""
+    if [ -n "$preset" ]; then
+        printf '%s%s [env]\n' "$prompt" "$preset"
+        printf -v "$__var" '%s' "$preset"
+        return 0
+    fi
+    # "Terminal yok" başsızlığın olağan biçimi, tek biçimi değil: screen,
+    # tmux ya da bir sunucudaki login kabuğunun terminali VARDIR ve önünde
+    # kimse yoktur. MULTI_AGENT_UNATTENDED=1 operatörün bunu açıkça söylemesi;
+    # refs/unattended-contract.md. Tanımsızken hiçbir şey değişmez.
+    if [ ! -t 0 ] || [ "${MULTI_AGENT_UNATTENDED:-}" = "1" ]; then
+        printf -v "$__var" '%s' ""
+        return 0
+    fi
+    # EOF (Ctrl-D) is an answer, not a crash: without `|| true` `set -e`
+    # turns a user pressing Ctrl-D into an exit with no message at all.
+    read -r -p "$prompt" reply || true
+    printf -v "$__var" '%s' "$reply"
+}
+
 echo "=== GitHub SSH Key Kurulumu ==="
 echo ""
 
 # E-posta adresi al
-read -p "GitHub e-posta adresinizi girin: " EMAIL
+ask "GitHub e-posta adresinizi girin: " "${SSH_SETUP_EMAIL:-}" EMAIL
 
 if [ -z "$EMAIL" ]; then
-    echo "Hata: E-posta adresi boş olamaz."
+    if [ -t 0 ] && [ "${MULTI_AGENT_UNATTENDED:-}" != "1" ]; then
+        echo "Hata: E-posta adresi boş olamaz."
+    else
+        if [ "${MULTI_AGENT_UNATTENDED:-}" = "1" ]; then
+            echo "Hata: MULTI_AGENT_UNATTENDED=1 ve SSH_SETUP_EMAIL tanımlı değil." >&2
+        else
+            echo "Hata: terminal yok ve SSH_SETUP_EMAIL tanımlı değil." >&2
+        fi
+        echo "      Başsız çalıştırmak için: SSH_SETUP_EMAIL=you@example.com $0" >&2
+    fi
     exit 1
 fi
 
@@ -26,7 +70,9 @@ chmod 700 "$HOME/.ssh"
 if [ -f "$KEY_PATH" ]; then
     echo ""
     echo "Uyari: $KEY_PATH zaten mevcut."
-    read -p "Üzerine yazmak istiyor musunuz? (e/h): " OVERWRITE
+    # Varsayılan HAYIR. Başsız bir koşuda cevapsız kalan bir "üzerine yazayım
+    # mı" sorusunun güvenli tarafı, var olan anahtarı korumaktır.
+    ask "Üzerine yazmak istiyor musunuz? (e/h): " "${SSH_SETUP_OVERWRITE:-}" OVERWRITE
     if [ "$OVERWRITE" != "e" ]; then
         echo "İşlem iptal edildi."
         exit 0
@@ -36,7 +82,11 @@ fi
 # SSH key oluştur (Ed25519 - modern ve güvenli)
 echo ""
 echo "SSH key oluşturuluyor..."
-ssh-keygen -t ed25519 -C "$EMAIL" -f "$KEY_PATH" -N ""
+# ssh-keygen var olan bir dosyayı görünce KENDİ "Overwrite (y/n)?" sorusunu
+# sorar - yani yukarıdaki onayı geçtikten sonra başsız koşu ikinci bir
+# soruda asılır. Onay zaten alındı; dosyayı önce kaldır.
+rm -f "$KEY_PATH" "${KEY_PATH}.pub"
+ssh-keygen -t ed25519 -C "$EMAIL" -f "$KEY_PATH" -N "" -q
 
 echo ""
 echo "SSH key başarıyla oluşturuldu!"
@@ -66,7 +116,12 @@ EOF
 fi
 
 # Key'i agent'a ekle (macOS Keychain ile)
-ssh-add --apple-use-keychain "$KEY_PATH" 2>/dev/null || ssh-add "$KEY_PATH"
+# Agent yoksa ekleme başarısız olur; anahtar yazıldıktan sonra bunun için
+# çıkmak, kurulumu yarıda bırakıp kullanıcıya hiçbir sonraki adımı
+# göstermemek demek.
+ssh-add --apple-use-keychain "$KEY_PATH" 2>/dev/null \
+  || ssh-add "$KEY_PATH" 2>/dev/null \
+  || echo "[Uyari: anahtar ssh-agent'a eklenemedi  -  elle: ssh-add $KEY_PATH]"
 
 # Public key'i göster ve kopyala
 echo ""
@@ -97,11 +152,13 @@ echo "4. 'Add SSH key' butonuna tıklayın"
 echo ""
 
 # GitHub'a key eklendikten sonra test
-read -p "Key'i GitHub'a ekledikten sonra test etmek ister misiniz? (e/h): " TEST
+ask "Key'i GitHub'a ekledikten sonra test etmek ister misiniz? (e/h): " "${SSH_SETUP_TEST:-}" TEST
 if [ "$TEST" = "e" ]; then
     echo ""
     echo "GitHub bağlantısı test ediliyor..."
-    ssh -T git@github.com 2>&1 || true
+    # Bilinmeyen host anahtarı üçüncü bir interaktif soru demek; başsız
+    # koşuda orada asılırdı.
+    ssh -o StrictHostKeyChecking=accept-new -T git@github.com 2>&1 || true
 fi
 
 echo ""

package/pipeline/scripts/graph-mermaid.mjs

@@ -41,6 +41,8 @@ import { resolve } from "node:path";
 import { parseFlags } from "./graph-build.mjs";
 import { loadGraph, defaultGraphPath } from "./graph-query.mjs";
 import { findByName, affected } from "./graph-affected.mjs";
+import { runMain } from "../lib/fatal.mjs";
+import { invokedDirectly } from "../lib/invoked-directly.mjs";
 
 const DEFAULT_MAX_NODES = 25;
 
@@ -246,6 +248,6 @@ function main() {
   }
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main();
+if (invokedDirectly(import.meta.url)) {
+  runMain("graph-mermaid", main);
 }