@galda/cli 0.10.22 → 0.10.23

package/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "galda",
+  "description": "Delegate work to Galda and clear your review queue without leaving Claude Code. Type /galda to see everything waiting on you — finished work needing sign-off, questions, blocked goals — and approve, send back, or answer it in place.",
+  "author": {
+    "name": "Kodo Inc."
+  },
+  "homepage": "https://galda.app",
+  "keywords": [
+    "galda",
+    "agent-manager",
+    "code-review",
+    "task-delegation"
+  ]
+}

package/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "galda": {
+      "command": "npx",
+      "args": ["-y", "-p", "@galda/cli", "galda-mcp"]
+    }
+  }
+}

package/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: galda
+description: Galda / Agent Manager の玄関口。溜まったレビューを見て返信・承認する、To Do を投げる、状況を見る。galda 関係のことはここから。Invoke with /galda.
+---
+
+<!--
+  The plugin's default skill. It MUST keep `name: galda` in the frontmatter —
+  without it Claude Code names the skill after the install directory, which for a
+  marketplace install is a version string that changes on every update, so the
+  command users learned would silently stop existing.
+-->
+
+You are the entry point to Galda / Agent Manager. Use the `galda` MCP server.
+Default project: `galda2`, unless the user names another.
+Answer in the user's language, short. Never implement the task yourself — Galda does the work.
+
+## 引数なしで `/galda` と打たれた時
+
+Call `manager_inbox` and show what is waiting on the user.
+
+- 1件1行。ゴール番号・何を聞かれているか／何を承認するのか・あればテスト結果とPR。
+- 質問には選択肢がついていることがある。**必ず選択肢も見せる**（それが返事のしかたなので）。
+- 出したら止まる。「何をしますか？」とは聞かない——リストが質問。
+- 何も無ければ「今、待ってるものは無い」とだけ言う。
+
+> `manager_inbox` が "unknown tool" で落ちたら、繋がっている Galda が古い。
+> `manager_status` にフォールバックし、`[review]` `[needsInput]` `[blocked]` の goal だけを
+> 拾って同じように見せた上で、「Galda が古いので一部しか見えていない（`npx @galda/cli` を
+> 新しくすると全部見える）」と一言添える。黙って少なく見せない。
+
+## 文章つきで `/galda 〜` と打たれた時
+
+何を言っているか判断して振り分ける。
+
+- **新しい依頼** → `manager_create_goal`（`deliverable: pr`）。文言はユーザーのまま渡す。
+- **番号への返事**（「456 は別リポジトリで」「440 dismiss」「23 approve」）→ 下の表。
+- **状況を知りたい** → `manager_inbox`（自分待ち）か `manager_status`（全体の流れ）。
+- **判断だけ欲しい／決めてほしい物を積む** → `manager_request_review`。
+
+迷ったら聞かずに `manager_inbox` を出して、そこから会話する。
+
+## 溜まったものを捌く
+
+`manager_inbox` が各グループに「次に呼ぶツール」を書いて返す。**それに従う**。要約:
+
+| inbox の見出し | 承認する | 却下・差し戻す |
+|---|---|---|
+| NEEDS YOUR ANSWER | `manager_answer(goalId, answer)` | — |
+| PLAN — approve to execute | `manager_approve` → **プランが実行される**（Done にはならない） | `manager_dismiss` |
+| DECISION — no worker ran | `manager_approve` → Done へ | `manager_dismiss` → 捨てる |
+| REVIEW | `manager_approve` → Done へ | `manager_dismiss(text)` → 直しの指示つきで worker に戻す |
+| BLOCKED | — | `manager_reply(text)` で指示 / `manager_dismiss` で捨てる |
+
+**NEEDS YOUR ANSWER に `manager_reply` を使わない。** 拒否されないが黙って壊れる——
+ワーカーが起動した上でゴールは質問したまま固まる。必ず `manager_answer`。
+
+承認・差し戻し・回答をした後は、**何がどう変わったかを一言で言う**（「456 に答えた → 再プラン中」）。
+まとめて何件も捌いた時だけ、最後にもう一度 `manager_inbox` を出して残りを見せる。
+
+## Galda が動いていない時
+
+`manager_*` が接続エラーで落ちたら、ローカルの Galda が起動していない。
+`npx @galda/cli` を実行するよう伝える（このプラグインは Galda 本体ではなく、その入口）。

package/engine/lib.mjs

@@ -2097,6 +2097,113 @@ export function buildAskContext(goals = [], tasks = []) {
   ].join('\n\n');
 }
 
+// ---- REVIEW INBOX (MCP) ----------------------------------------------------
+// 「Claude から /galda と打ったら、galda が自分待ちで止まっている物が全部見えて、
+// その場で捌ける」ための一覧。manager_status は goal を status 無関係に直近12件で
+// 切っていたので、レビューに入ったまま古くなった goal は MCP から**黙って消えて
+// いた**——「溜まったレビュー」がまさに見えない、という逆をやっていた。ここは
+// status で引くので件数では落ちない。
+//
+// ラベルの流儀は buildAskContext と同じ（reviewSummary.check → plan[0] → text）。
+// 人間待ちは1種類ではないので kind で分ける——同じ「レビュー」でも次の一手が違う:
+//   plan     … 承認するとプランが**実行される**（done にはならない。nextAfterPlanApprove）
+//   decision … reviewOnly。worker は走っていない。Dismiss は skipped で捨てるだけ
+//   review   … 通常。Approve→done / Dismiss→running に戻して修正指示を返信タスクに積む
+//   question … needsInput。/reply は 409。専用の /answer に answer を送る
+//   blocked  … worker のスレッドが無いので Dismiss は skipped。修正指示は reply
+const inboxLabel = (g) => (g.reviewSummary?.check || g.plan?.[0] || g.text || '').replace(/\s+/g, ' ').trim().slice(0, 100);
+
+export function inboxKind(goal) {
+  if (!goal) return null;
+  if (isPlanReview(goal)) return 'plan';
+  if (goal.status === 'review') return goal.reviewOnly ? 'decision' : 'review';
+  if (goal.status === 'needsInput') return 'question';
+  if (goal.status === 'blocked') return 'blocked';
+  return null;
+}
+
+// kind ごとの「次の一手」。MCP のツール名で書く——読むのが人間ではなく Claude で、
+// そのまま呼べる形にしておかないと、承認と差し戻しを取り違える。
+// question に「reply は使うな」と明記しているのは実測の結果: POST /reply は
+// stacked/planning しか弾かないので needsInput の goal にも**通ってしまい**、答えを
+// 畳み込んで再プランする代わりにワーカータスクを積んだ上、goal は needsInput のまま
+// 質問し続ける（running に戻す分岐にも入らない）。弾かれるより悪い＝黙って違うことを
+// するので、ここで行き先を固定する。
+export const INBOX_ACTIONS = {
+  plan: 'manager_approve → runs the approved plan (does NOT file to Done) / manager_dismiss → sends it back',
+  decision: 'manager_approve → files it to Done / manager_dismiss → drops it (no worker runs either way)',
+  review: 'manager_approve → files it to Done / manager_dismiss(text) → sends it back to the worker with your fix note',
+  question: 'manager_answer(answer) → answers it; the goal re-plans and continues. NOT manager_reply — it is accepted but queues a worker instead of answering, and the goal stays stuck asking.',
+  blocked: 'manager_reply(text) → tells the worker what to do / manager_dismiss → drops it',
+};
+
+export function buildReviewInbox(goals = [], { project } = {}) {
+  return goals
+    .filter((g) => !project || g.projectId === project)
+    .map((g) => ({ g, kind: inboxKind(g) }))
+    .filter((x) => x.kind)
+    // 古い順。「溜まった」物こそ本題なので、新しい方から数えて切り捨てない。
+    .sort((a, b) => a.g.id - b.g.id)
+    .map(({ g, kind }) => {
+      const tr = g.testResult;
+      const opts = g.question?.options;
+      return {
+        goalId: g.id,
+        projectId: g.projectId ?? null,
+        kind,
+        label: inboxLabel(g),
+        tests: tr?.ran ? { passed: tr.passed ?? 0, failed: tr.failed ?? 0 } : null,
+        pr: g.pr || null,
+        question: kind === 'question' && g.question?.text
+          ? {
+            text: String(g.question.text).replace(/\s+/g, ' ').trim().slice(0, 200),
+            options: Array.isArray(opts) ? opts.map((o) => String(o).replace(/\s+/g, ' ').trim()).slice(0, 8) : [],
+          }
+          : null,
+        blockedReason: kind === 'blocked'
+          ? String(g.blocked?.reason ?? 'blocked').replace(/\s+/g, ' ').trim().slice(0, 120)
+          : null,
+      };
+    });
+}
+
+const INBOX_KIND_HEADING = {
+  question: 'NEEDS YOUR ANSWER',
+  plan: 'PLAN — approve to execute',
+  decision: 'DECISION — no worker ran',
+  review: 'REVIEW',
+  blocked: 'BLOCKED',
+};
+// 止まっているものから先に。question/plan は答えるまで前に進まないので上。
+const INBOX_KIND_ORDER = ['question', 'plan', 'decision', 'review', 'blocked'];
+
+// kind ごとにまとめ、「次の一手」は1グループ1回だけ書く。これを item ごとに繰り返すと、
+// レビューが20件溜まった時に同じ一文を20回読ませることになる——読み手は Claude なので
+// それはそのままトークンの無駄。
+export function formatReviewInbox(items = []) {
+  if (!items.length) return 'Nothing is waiting on you.';
+  const sections = INBOX_KIND_ORDER
+    .map((kind) => [kind, items.filter((it) => it.kind === kind)])
+    .filter(([, list]) => list.length)
+    .map(([kind, list]) => {
+      const lines = [`## ${INBOX_KIND_HEADING[kind]} — ${list.length}`, INBOX_ACTIONS[kind]];
+      for (const it of list) {
+        const tail = [
+          it.tests ? `tests ${it.tests.passed}✓${it.tests.failed ? `/${it.tests.failed}✗` : ''}` : null,
+          it.pr ? `PR: ${it.pr}` : null,
+          it.blockedReason ? `blocked: ${it.blockedReason}` : null,
+        ].filter(Boolean);
+        lines.push(`[goal ${it.goalId}] (${it.projectId}) ${it.label}${tail.length ? ` — ${tail.join(' — ')}` : ''}`);
+        if (it.question) {
+          lines.push(`  Q: ${it.question.text}`);
+          if (it.question.options.length) lines.push(`  options: ${it.question.options.join(' | ')}`);
+        }
+      }
+      return lines.join('\n');
+    });
+  return [`${items.length} waiting on you (oldest first within each group):`, ...sections].join('\n\n');
+}
+
 // Goal statuses that count as "finished" for showing the goal-level
 // conclusion summary in chat (task 86) — mirrored in app/index.html's
 // goalRow (GOAL_COMPLETE_STATUSES) since that inline script can't import
@@ -3113,7 +3220,7 @@ export function relayReconnectDecision(state, event) {
   }
 }
 
-// --- Relay-client single-instance guard (2026-07-17, five incidents deep) -----
+// --- Relay-client single-instance guard (2026-07-17, six incidents deep) -----
 // Every relay mutual-kick incident so far (#86/#88/#106, and the one that
 // prompted this) traces back to the SAME root: nothing has ever stopped more
 // than one relay-client process from authenticating as the same account at
@@ -3126,13 +3233,36 @@ export function relayReconnectDecision(state, event) {
 // closes that gap at the one point it can be closed structurally: refuse to
 // start a second live process against the same DATA_DIR at all, the same
 // pattern tools/lane.mjs uses for hot-file locks (fail at start time, not
-// after the fact). `alive` is passed in (not computed here) so this stays a
-// pure decision — the caller does the actual process.kill(pid, 0) liveness
-// check (real I/O, not testable as a pure function).
-export function shouldRefuseRelayClientStart({ existingLock, alive } = {}) {
-  if (!existingLock || !Number.isFinite(existingLock.pid)) return { refuse: false, reason: 'no-lock' };
-  if (!alive) return { refuse: false, reason: 'stale-lock' };
-  return { refuse: true, reason: 'already-running', holderPid: existingLock.pid };
+// after the fact).
+//
+// First cut just refused outright, full stop. Masa (2026-07-17): that is
+// unfriendly — Figma/Notion/ChatGPT all let you have multiple accounts, and
+// signing into the "wrong" one by habit is a completely normal thing to do.
+// A flat refusal makes a NORMAL action (switch accounts on this device) look
+// exactly like an ERROR, with no path forward except reading a hint and
+// typing a different command by hand. So: classify the conflict instead of
+// just flagging it. Same account already connected here → still refuse,
+// nothing useful to offer (switching to yourself is a no-op). A DIFFERENT
+// account → this is a legitimate everyday action, not a fault condition, so
+// offer to switch right there instead of just describing how to (relay-
+// client.mjs prompts interactively and takes over on 'y').
+// `alive` is passed in (not computed here) so this stays a pure decision —
+// the caller does the actual process.kill(pid, 0) liveness check (real I/O,
+// not testable as a pure function).
+export function classifyRelayClientConflict({ existingLock, alive, newIdentity } = {}) {
+  if (!existingLock || !Number.isFinite(existingLock.pid)) return { action: 'proceed', reason: 'no-lock' };
+  if (!alive) return { action: 'proceed', reason: 'stale-lock' };
+  const holderIdentity = existingLock.identity || null;
+  const holderPid = existingLock.pid;
+  if (holderIdentity && newIdentity && holderIdentity === newIdentity) {
+    return { action: 'refuse', reason: 'same-account-already-connected', holderPid, holderIdentity };
+  }
+  if (holderIdentity && newIdentity && holderIdentity !== newIdentity) {
+    return { action: 'offer-switch', reason: 'different-account', holderPid, holderIdentity };
+  }
+  // Identity unknown on one/both sides (e.g. not signed in yet) — can't tell
+  // whether switching is meaningful, so default to the safe, old behavior.
+  return { action: 'refuse', reason: 'unknown-identity', holderPid, holderIdentity };
 }
 
 // --- Connect-gate account-mismatch escalation (2026-07-17) ------------------

package/engine/mcp.mjs

@@ -14,6 +14,7 @@ import { readFileSync, existsSync } from 'node:fs';
 import { resolve, dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
+import { buildReviewInbox, formatReviewInbox } from './lib.mjs';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const DATA_DIR = process.env.MANAGER_HOME
@@ -81,7 +82,7 @@ const TOOLS = [
   },
   {
     name: 'manager_reply',
-    description: 'Reply in a goal thread. The reply resumes the worker session for that goal, so context carries over.',
+    description: 'Reply in a goal thread. The reply resumes the worker session for that goal, so context carries over. Do NOT use this on a goal awaiting a question ("Needs your answer" / needsInput) — the server accepts it but it queues a worker instead of answering, leaving the goal stuck; use manager_answer there.',
     inputSchema: { type: 'object', properties: {
       goalId: { type: 'number' }, text: { type: 'string' },
     }, required: ['goalId', 'text'] },
@@ -91,6 +92,59 @@ const TOOLS = [
       return `Reply queued as task ${t.id} on goal ${a.goalId}.`;
     },
   },
+  {
+    name: 'manager_inbox',
+    description: 'Show everything in Manager that is waiting on the HUMAN right now — the Review lane (work finished, needs a sign-off), plan approvals, review-only decisions, unanswered questions ("Needs your answer"), and blocked goals. Use this whenever the user asks what needs their attention / what is in review / what is waiting / "anything for me?". Unlike manager_status (which lists only the 12 most recent goals regardless of status, so old pending reviews silently vanish), this is filtered by status and never truncated. Each item tells you which follow-up tool to call.',
+    inputSchema: { type: 'object', properties: {
+      project: { type: 'string', description: 'optional project id filter (e.g. galda1, galda2)' },
+    } },
+    run: async (a) => {
+      const s = await api('/api/state');
+      return formatReviewInbox(buildReviewInbox(s.goals ?? [], { project: a.project }));
+    },
+  },
+  {
+    name: 'manager_approve',
+    description: 'Approve a goal that is sitting in the Review lane. For a normal review this files the goal to Done. For a PLAN review (kind "plan" in manager_inbox) it does NOT file to Done — it runs the approved plan, i.e. the worker now actually makes the edits. Check manager_inbox for the kind before telling the user what approving will do.',
+    inputSchema: { type: 'object', properties: {
+      goalId: { type: 'number' },
+    }, required: ['goalId'] },
+    run: async (a) => {
+      const g = await api(`/api/goals/${a.goalId}/approve`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{}' });
+      return g.status === 'done'
+        ? `Approved: goal ${a.goalId} filed to Done.`
+        : `Approved: goal ${a.goalId} is now [${g.status}] — the approved plan is executing.`;
+    },
+  },
+  {
+    name: 'manager_dismiss',
+    description: 'Dismiss a goal in the Review lane. For a normal review this sends it BACK to the worker to be fixed (pass `text` with what to fix — it is delivered as a thread reply and the worker resumes). For a review-only decision or a blocked goal there is no worker thread, so this just drops the item (filed as skipped) and `text` is ignored. Not an "approve" — never use this to sign something off.',
+    inputSchema: { type: 'object', properties: {
+      goalId: { type: 'number' },
+      text: { type: 'string', description: 'what to fix — sent to the worker. Ignored for review-only / blocked items.' },
+    }, required: ['goalId'] },
+    run: async (a) => {
+      const r = await api(`/api/goals/${a.goalId}/dismiss`, { method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ text: a.text }) });
+      const status = r.goal?.status ?? r.status;
+      return status === 'skipped'
+        ? `Dismissed: goal ${a.goalId} dropped (skipped). No worker ran.`
+        : `Sent back: goal ${a.goalId} is now [${status}] — the worker is revising it.`;
+    },
+  },
+  {
+    name: 'manager_answer',
+    description: 'Answer a goal that is waiting on a question ("Needs your answer" / kind "question" in manager_inbox). The answer is folded into the goal, which then re-plans and continues — no new goal is created. Always use this, never manager_reply, for a question goal: manager_reply is NOT rejected for them, it is silently wrong — it queues a worker task with your text while the goal stays stuck asking the same question. If manager_inbox listed options, prefer answering with one of them.',
+    inputSchema: { type: 'object', properties: {
+      goalId: { type: 'number' },
+      answer: { type: 'string', description: 'the answer, natural language (or one of the listed options)' },
+    }, required: ['goalId', 'answer'] },
+    run: async (a) => {
+      const g = await api(`/api/goals/${a.goalId}/answer`, { method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ answer: a.answer }) });
+      return `Answered: goal ${a.goalId} is now [${g.status}] in ${g.projectId}.`;
+    },
+  },
 ];
 
 function reply(id, result) { process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n'); }

package/engine/relay-client.mjs

@@ -12,7 +12,9 @@ import { readFileSync, writeFileSync, existsSync, watch, unlinkSync } from 'node
 import { resolve, dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { licenseTokenIdentity, relayReconnectDecision, shouldRefuseRelayClientStart } from './lib.mjs';
+import { createInterface } from 'node:readline/promises';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { licenseTokenIdentity, relayReconnectDecision, classifyRelayClientConflict } from './lib.mjs';
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const DATA_DIR = process.env.MANAGER_HOME
@@ -182,12 +184,17 @@ function handleTakeover() {
   if (d.dial) { console.log('[agent] taking over this account on this device (user requested)'); redialNow(); }
 }
 
-// Single-instance guard (2026-07-17): refuse to start a second relay-client
-// against the same DATA_DIR. See lib.mjs shouldRefuseRelayClientStart for why —
-// this is the one point that actually stops the "N processes, one account"
-// mutual-kick class of incident, rather than making each process behave
-// better once it's already one of several. RELAY_CLIENT_FORCE=1 overrides for
-// the rare legitimate case (you know two are up and you're taking over by hand).
+// Single-instance guard (2026-07-17): refuse a second relay-client against the
+// same DATA_DIR for the SAME account (nothing to offer — that's still exactly
+// the mutual-kick precondition); OFFER TO SWITCH for a DIFFERENT account. See
+// lib.mjs classifyRelayClientConflict for the decision and why a flat refusal
+// (the first cut, same night) wasn't good enough: Masa — "Figma/Notion/ChatGPT
+// all let you have multiple accounts... signing into the wrong one by habit
+// happens... a silent infinite wait doesn't tell the user anything." Switching
+// accounts on a device you already use Galda on is a normal action, not an
+// error, so it gets a normal confirm-and-go prompt, not a wall of text to
+// decode. RELAY_CLIENT_FORCE=1 skips the prompt entirely (scripts, CI, "I
+// already know, just do it").
 const LOCK_FILE = join(DATA_DIR, 'relay-client.lock');
 function readLock() {
   try { return JSON.parse(readFileSync(LOCK_FILE, 'utf8')); } catch { return null; }
@@ -197,7 +204,7 @@ function isPidAlive(pid) {
   try { process.kill(pid, 0); return true; } catch { return false; }
 }
 function writeLock() {
-  try { writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, startedAt: Date.now() })); } catch { /* best-effort */ }
+  try { writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, startedAt: Date.now(), identity: currentIdentity || null })); } catch { /* best-effort */ }
 }
 function releaseLock() {
   try {
@@ -206,16 +213,70 @@ function releaseLock() {
   } catch { /* already gone */ }
 }
 
-if (!process.env.RELAY_CLIENT_NO_START) {
+// The actual takeover mechanics (kill the old holder, wait for its lock to
+// really clear) — split out from the interactive prompt around it so this
+// part is testable without a real TTY (engine/test/relay-standdown.test.mjs
+// exercises this directly against two real processes; the y/N prompt itself
+// needs a pty, which isn't worth a new dependency for).
+async function takeOverFromHolder(holderPid) {
+  try { process.kill(holderPid, 'SIGTERM'); } catch { /* already gone */ }
+  // The old process's own SIGTERM handler releases its lock; wait for that
+  // rather than racing to write ours the instant the signal is sent.
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    const l = readLock();
+    if (!l || !isPidAlive(l.pid)) return true;
+    await sleep(150);
+  }
+  return !isPidAlive(readLock()?.pid);
+}
+
+// Prompts (only when this is a real terminal — never blocks a script/CI run)
+// to switch, then hands off to takeOverFromHolder(). Returns true iff we
+// should proceed as the new identity; false means "stay refused, exit".
+async function offerAccountSwitch(conflict) {
+  if (!process.stdin.isTTY) {
+    console.error(`[agent] relay-client: Galda is already connected on this device as ${conflict.holderIdentity} (pid ${conflict.holderPid}).`);
+    console.error(`[agent] This sign-in is for a different account (${currentIdentity}). Re-run in an interactive terminal to be prompted to switch, or set RELAY_CLIENT_FORCE=1.`);
+    return false;
+  }
+  console.log(`[agent] Galda is already connected on this device as ${conflict.holderIdentity}.`);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  let answer;
+  try { answer = (await rl.question(`[agent] Switch this device to ${currentIdentity} instead? [y/N] `)).trim().toLowerCase(); }
+  finally { rl.close(); }
+  if (answer !== 'y' && answer !== 'yes') {
+    console.log('[agent] Keeping the existing connection — nothing changed.');
+    return false;
+  }
+  console.log(`[agent] Switching... stopping the previous session (${conflict.holderIdentity}, pid ${conflict.holderPid})`);
+  await takeOverFromHolder(conflict.holderPid);
+  console.log(`[agent] Connecting as ${currentIdentity}...`);
+  return true;
+}
+
+async function acquireLockOrExit() {
+  if (process.env.RELAY_CLIENT_FORCE) { writeLock(); return; }
   const existingLock = readLock();
-  const guard = shouldRefuseRelayClientStart({ existingLock, alive: existingLock ? isPidAlive(existingLock.pid) : false });
-  if (guard.refuse && !process.env.RELAY_CLIENT_FORCE) {
-    console.error(`[agent] relay-client: another instance is already running for this account (pid ${guard.holderPid}, ${DATA_DIR}).`);
+  const conflict = classifyRelayClientConflict({ existingLock, alive: existingLock ? isPidAlive(existingLock.pid) : false, newIdentity: currentIdentity || null });
+  if (conflict.action === 'proceed') { writeLock(); return; }
+  if (conflict.action === 'offer-switch') {
+    if (await offerAccountSwitch(conflict)) { writeLock(); return; }
+    process.exit(1);
+  }
+  // action === 'refuse'
+  if (conflict.reason === 'same-account-already-connected') {
+    console.error(`[agent] relay-client: already connected on this device as ${conflict.holderIdentity} (pid ${conflict.holderPid}) — nothing to do.`);
+  } else {
+    console.error(`[agent] relay-client: another instance is already running for this account (pid ${conflict.holderPid}, ${DATA_DIR}).`);
     console.error('[agent] Running two at once is exactly what causes the relay mutual-kick loop — stop the other one first.');
     console.error('[agent] If you are certain (e.g. taking over by hand), set RELAY_CLIENT_FORCE=1 and re-run.');
-    process.exit(1);
   }
-  writeLock();
+  process.exit(1);
+}
+
+if (!process.env.RELAY_CLIENT_NO_START) {
+  await acquireLockOrExit();
   process.on('exit', releaseLock);
   for (const sig of ['SIGINT', 'SIGTERM']) process.on(sig, () => { releaseLock(); process.exit(0); });
 
@@ -248,4 +309,4 @@ if (!process.env.RELAY_CLIENT_NO_START) {
   } catch { /* fs.watch unavailable on this platform */ }
 }
 
-export { redialNow, handleTakeover };
+export { redialNow, handleTakeover, takeOverFromHolder };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galda/cli",
-  "version": "0.10.22",
+  "version": "0.10.23",
   "type": "module",
   "description": "Galda - hand off work to Claude Code or Codex, get proof back. Runs on your existing subscription, no extra API cost.",
   "scripts": {
@@ -13,13 +13,17 @@
   },
   "license": "UNLICENSED",
   "bin": {
-    "galda": "bin/manager-for-ai.mjs"
+    "galda": "bin/manager-for-ai.mjs",
+    "galda-mcp": "engine/mcp.mjs"
   },
   "files": [
     "app/",
     "engine/",
     "bin/manager-for-ai.mjs",
     "examples/",
+    ".claude-plugin/",
+    "SKILL.md",
+    ".mcp.json",
     "README.md",
     "CLAUDE.md",
     "!engine/chat-runs",