jeo-code 0.11.2 → 0.11.4

package/src/agent/engine.ts

@@ -276,15 +276,12 @@ export interface AgentLoopEvents {
   /** Step-budget change (gjc-style retry flow): the limit was extended because the
    *  turn is making progress. `limit` is the new max; `reason` is display-ready. */
   onBudget?(limit: number, reason: string): void;
-  /** Consulted when a lone `done` arrives. Return a corrective message to bounce
-   *  the done ONCE (e.g. "todo list still shows unfinished items — update it
-   *  first"); return null to let the turn finish. The engine guarantees at most
-   *  one bounce per turn, so a stubborn model can never loop here. `evidence` is
-   *  the SAME mutation/verification signal the engine's own done-gate already
-   *  computed (see `classifyDoneGate` above) — a caller-owned gate (e.g. the goal
-   *  verifier) can use it to deterministically downgrade an LLM-judged MET verdict
-   *  when the turn mutated files without a fresh passing verification, instead of
-   *  trusting the transcript self-report alone. */
+  /** Consulted on every completion attempt, including salvaged prose. Return a
+   *  corrective message to defer completion; null approves the caller-owned gate.
+   *  Corrections are bounded by GUARD_LIMITS.MAX_DONE_CORRECTIONS, after which a
+   *  rejected attempt stops incomplete. `evidence` is the SAME mutation/verification
+   *  signal the engine's own done-gate uses, so callers can reject unsupported
+   *  transcript-only success claims. */
   onBeforeDone?(
     reason: string,
     evidence: { sawMutation: boolean; sawVerification: boolean; verificationStale: boolean }
@@ -583,10 +580,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   // calls (bad edits, failing commands) would otherwise burn the whole step budget.
   const MAX_FAILURES = GUARD_LIMITS.MAX_FAILURES;
   let consecutiveFailures = 0;
-  // done-verification guard (plan/gjc-inheritance.md B4, gjc ultragoal-guard 경량 계승):
-  // a turn that MUTATED files but shows no verification signal gets ONE pushback on
-  // `done` — run the relevant test/build, or call done again (the escape hatch for
-  // doc/config changes where verification is genuinely not applicable).
+  // Completion requires fresh passing verification after a successful mutation.
   let sawMutation = false;
   let sawVerification = false;
   // Monotonic ordering of mutation vs. verification events so the done gate can
@@ -595,16 +589,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   let mutVerSeq = 0;
   let lastMutationSeq = 0;
   let lastVerificationSeq = 0;
-  let donePushbackUsed = false;
-  // Abuse guard for the done-pushback escape hatch: the "second done always
-  // passes" latch below is meant for turns where verification is genuinely
-  // not applicable (docs/config-only changes) — not for a model that just
-  // resends `done` immediately with zero intervening action. Reset to false
-  // when the first pushback fires; any executed tool step (even read-only)
-  // sets it back to true, so the escape hatch requires at least one attempt.
-  let sawActionSincePushback = true;
-  // Caller-owned done gate (onBeforeDone) — also strictly once per turn.
-  let beforeDoneNudgeUsed = false;
+  let doneCorrections = 0;
   // F1 (round 4): the run-command of the most recent post-turn hook FAILURE whose
   // diagnostics the model saw but has not yet resolved (a later clean hook run
   // clears it). The done guard treats this as "verification missing" — the hook
@@ -981,6 +966,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     if (sawUsage) ev.onUsage?.({ ...acc }, lastCallUsage ? { ...lastCallUsage } : undefined);
 
     let invocation: any;
+    let salvagedAnswer = false;
     try {
       const extracted = extractJsonObjectWithSpan<any>(responseText, { preferKeys: ["tool", "tools"] });
       invocation = extracted.value;
@@ -991,30 +977,27 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
       // would reinforce the corruption instead of self-correcting.
       responseText = extracted.matched;
     } catch (err) {
-      ev.onAssistant?.(responseText, null);
-      // Prose salvage: a reply with no JSON object at all is a chat-style final
-      // answer, not a malformed tool call. Bouncing it back only made the model
-      // apologize for the format — and that apology surfaced as the visible reply.
-      // Same salvage after repeated bounces: the text we have IS the best answer.
+      // Preserve chat-style final answers, but subject them to the same completion
+      // gates as explicit done calls rather than treating prose as proof of success.
       const trimmed = responseText.trim();
       parseFailures++;
       if (trimmed && (!trimmed.includes("{") || parseFailures > MAX_PARSE_BOUNCES)) {
+        salvagedAnswer = true;
+        invocation = { tool: "done", arguments: { reason: stripLeakedReasoningTags(trimmed) || trimmed } };
+      } else {
+        ev.onAssistant?.(responseText, null);
         pushAssistantTurn(history, responseText, reasonBuf, artifactBuf);
-        // Strip leaked <think>/<parameter>/Harmony scaffolding some API-entered
-        // models emit inline so the salvaged answer doesn't surface raw tags.
-        return finish({ done: true, steps: step, doneReason: stripLeakedReasoningTags(trimmed) || trimmed });
+        history.push({
+          role: "user",
+          content:
+            `Your last reply was not a valid tool call (${(err as Error).message}). ` +
+            `Do NOT apologize or explain the formatting mistake. If that reply was your final answer, ` +
+            `resend it as {"tool":"done","arguments":{"reason":"<that answer, verbatim>"}}; ` +
+            `otherwise reply with exactly one JSON tool call: {"tool":"<name>","arguments":{...}}.`,
+        });
+        step++;
+        continue;
       }
-      pushAssistantTurn(history, responseText, reasonBuf, artifactBuf);
-      history.push({
-        role: "user",
-        content:
-          `Your last reply was not a valid tool call (${(err as Error).message}). ` +
-          `Do NOT apologize or explain the formatting mistake. If that reply was your final answer, ` +
-          `resend it as {"tool":"done","arguments":{"reason":"<that answer, verbatim>"}}; ` +
-          `otherwise reply with exactly one JSON tool call: {"tool":"<name>","arguments":{...}}.`,
-      });
-      step++;
-      continue;
     }
     // A successfully parsed reply ends any bounce streak: MAX_PARSE_BOUNCES is a
     // CONSECUTIVE-failure salvage, not a cumulative one — without this reset a long
@@ -1066,64 +1049,27 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
       toolCalls = toolCalls.slice(0, 6);
     }
 
-    ev.onAssistant?.(responseText, toolCalls[0]);
+    ev.onAssistant?.(responseText, salvagedAnswer ? null : toolCalls[0]);
 
     if (toolCalls.length === 1 && toolCalls[0].tool === "done") {
-      // done-verification gate — jeo's descendant of gjc's ultragoal-guard completion
-      // state machine (plan/gjc-inheritance.md B4). The classifier owns the JUDGMENT
-      // (which named state, which message); the loop owns the once-pushback latch.
-      const doneGate = classifyDoneGate({
+      const evidence = {
         sawMutation,
         sawVerification,
         verificationStale: sawMutation && lastMutationSeq > lastVerificationSeq,
-        pendingHookFailure,
-      });
-      if (doneGate.block) {
-        if (!donePushbackUsed) {
-          donePushbackUsed = true;
-          sawActionSincePushback = false; // require a real attempt before the 2nd done is honored
-          pushAssistantTurn(history, responseText, reasonBuf, artifactBuf);
-          history.push({ role: "user", content: doneGate.message });
-          step++;
-          continue;
-        }
-        if (!sawActionSincePushback) {
-          // Abuse guard: the model re-sent `done` immediately with zero intervening
-          // tool calls — not the intended "verification genuinely not applicable"
-          // escape hatch. Bounce once more instead of silently accepting it.
-          pushAssistantTurn(history, responseText, reasonBuf, artifactBuf);
-          history.push({
-            role: "user",
-            content:
-              `${doneGate.message}\n\nYou called 'done' again without taking any further action. ` +
-              `Either run the relevant verification (test/build/lint) or take another concrete step, ` +
-              `then call done — do not resend 'done' unchanged.`,
-          });
-          step++;
-          continue;
-        }
-        // donePushbackUsed && sawActionSincePushback: the model made at least one
-        // real attempt since the pushback — honor the escape hatch.
-      }
-      // Caller-owned done gate (e.g. stale-todo reconciliation): ONE bounded
-      // bounce, then any later done passes — field case: a 28-step turn ended
-      // [DONE] with the Todos checklist still showing 1 in-progress + 4 pending
-      // because nothing ever forced a status update.
-      if (!beforeDoneNudgeUsed && ev.onBeforeDone) {
-        const nudge = await ev.onBeforeDone((toolCalls[0].arguments?.reason as string) ?? "", {
-          sawMutation,
-          sawVerification,
-          verificationStale: sawMutation && lastMutationSeq > lastVerificationSeq,
-        });
-
-        if (nudge) {
-          beforeDoneNudgeUsed = true;
-          pushAssistantTurn(history, responseText, reasonBuf, artifactBuf);
-          history.push({ role: "user", content: nudge });
-          ev.onNotice?.("done deferred once — final plan reconciliation requested");
-          step++;
-          continue;
+      };
+      const doneGate = classifyDoneGate({ ...evidence, pendingHookFailure });
+      const nudge = await ev.onBeforeDone?.((toolCalls[0].arguments?.reason as string) ?? "", evidence);
+      const rejection = [doneGate.block ? doneGate.message : "", nudge].filter(Boolean).join("\n\n");
+      if (rejection) {
+        if (doneCorrections >= GUARD_LIMITS.MAX_DONE_CORRECTIONS) {
+          return finish({ done: false, steps: step, doneReason: `Stopped: completion rejected after ${doneCorrections} corrections. ${rejection}` });
         }
+        doneCorrections++;
+        pushAssistantTurn(history, responseText, reasonBuf, artifactBuf);
+        history.push({ role: "user", content: rejection });
+        ev.onNotice?.(`done deferred — completion correction ${doneCorrections}/${GUARD_LIMITS.MAX_DONE_CORRECTIONS}`);
+        step++;
+        continue;
       }
       // Steering that arrived DURING this final step (after the top-of-loop drain,
       // while the model was generating its `done`): reopen the turn and handle it now
@@ -1148,6 +1094,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
           continue;
         }
       }
+      if (salvagedAnswer) pushAssistantTurn(history, responseText, reasonBuf, artifactBuf);
       return finish({ done: true, steps: step, doneReason: stripLeakedReasoningTags((toolCalls[0].arguments?.reason as string) ?? "") });
     }
 
@@ -1445,20 +1392,18 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
       if (results[i].executed) budget.record(callSigs[i], results[i].success, callTargets[i]);
 
     }
-    // done-verification guard bookkeeping: write/edit successes mark the turn as
-    // mutating; a successful bash whose command/output looks like a test/build run
-    // counts as verification. A monotonic seq records ORDER so the done gate can
-    // reject a verification that predates the last mutation (stale evidence).
+    // Only the latest recognized verification result is evidence; a later failure
+    // invalidates earlier success. Sequence numbers also reject tests before edits.
     for (let i = 0; i < toolCalls.length; i++) {
-      if (!results[i].executed || !results[i].success) continue;
+      if (!results[i].executed) continue;
       const t = toolCalls[i].tool;
-      if (t === "write" || t === "edit") {
+      if ((t === "write" || t === "edit") && results[i].success) {
         sawMutation = true;
         lastMutationSeq = ++mutVerSeq;
       } else if (t === "bash") {
         const cmd = String(toolCalls[i].arguments?.command ?? "");
         if (isVerificationSignal(cmd, results[i].output)) {
-          sawVerification = true;
+          sawVerification = results[i].success;
           lastVerificationSeq = ++mutVerSeq;
         }
       }
@@ -1494,7 +1439,6 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     // Executed tool step = progress: the stall budget clocks time WITHOUT this.
     if (results.some(r => r.executed)) {
       lastProgressAt = Date.now();
-      sawActionSincePushback = true; // any real step after a pushback re-enables the done escape hatch
     }
     step++;
   }

package/src/agent/loop-guards.ts

@@ -41,6 +41,8 @@ export const GUARD_LIMITS = Object.freeze({
   MAX_REPEAT: 4,
   /** Consecutive different-but-failing steps before the turn stops. */
   MAX_FAILURES: 5,
+  /** Rejected completion attempts that may request a correction before stopping incomplete. */
+  MAX_DONE_CORRECTIONS: 3,
   /** Context-mutating refusal-ladder rungs (resend → reset → guidance strip) before
    *  recovery switches to unbounded backoff resends (gjc parity: never terminal). */
   MAX_REFUSAL_RETRIES: 3,
@@ -114,7 +116,7 @@ export function repeatHint(tool: string, prev?: { success: boolean; output: stri
 export interface DoneGateInput {
   /** A write/edit succeeded this turn. */
   sawMutation: boolean;
-  /** A test/build/typecheck/lint command succeeded this turn. */
+  /** The most recent recognized test/build/typecheck/lint command succeeded. */
   sawVerification: boolean;
   /**
    * A mutation landed AFTER the most recent successful verification — so the
@@ -129,7 +131,7 @@ export interface DoneGateInput {
 /** Verdict from {@link classifyDoneGate}: whether to bounce `done`, and the message. */
 export interface DoneGateVerdict {
   state: Extract<GuardState, "done_ok" | "done_unverified" | "done_stale_verification" | "done_hook_failing">;
-  /** When true, `done` should be bounced ONCE with `message` (the caller owns the once-gate). */
+  /** When true, completion must remain blocked until the condition is resolved. */
   block: boolean;
   /** Corrective message to push back on `done`; empty when `state === "done_ok"`. */
   message: string;
@@ -139,10 +141,9 @@ export interface DoneGateVerdict {
  * Classify whether a `done` should be accepted or bounced — the direct descendant of
  * gjc's `ultragoal-guard` completion gate (plan/gjc-inheritance.md B4).
  *
- * A turn that MUTATED files is blocked ONCE when its verification is missing
- * (no test/build signal), STALE (a passing run that predates the last edit), or
- * a post-turn hook is still failing. The caller owns the single-pushback latch; a
- * second `done` always passes (the escape hatch for unverifiable docs/config changes).
+ * A turn that MUTATED files remains blocked while verification is missing/failed,
+ * STALE (a passing run predates the last edit), or a post-turn hook is still failing.
+ * The caller bounds corrective retries without converting rejection into success.
  */
 export function classifyDoneGate(input: DoneGateInput): DoneGateVerdict {
   const hookFailing = input.pendingHookFailure !== null;
@@ -155,8 +156,7 @@ export function classifyDoneGate(input: DoneGateInput): DoneGateVerdict {
       block: true,
       message:
         `Your latest mutation left the post-turn hook "${input.pendingHookFailure}" FAILING (non-zero exit) — its diagnostics were shown in the tool result above. ` +
-        "Fix the reported problems (the hook re-runs on your next mutation), then call done. " +
-        "If the hook failure is a false positive, call done again and say why in the reason.",
+        "Fix the reported problems (the hook re-runs on your next mutation), then call done.",
     };
   }
   if (stale) {
@@ -165,16 +165,14 @@ export function classifyDoneGate(input: DoneGateInput): DoneGateVerdict {
       block: true,
       message:
         "You verified earlier, but then modified files again — your last passing test/build no longer reflects the current tree. " +
-        "Re-run the narrowest verification command against the latest changes, then call done. " +
-        "If the later edits are verification-irrelevant (docs/config-only), call done again and say why in the reason.",
+        "Re-run the narrowest verification command against the latest changes, then call done.",
     };
   }
   return {
     state: "done_unverified",
     block: true,
     message:
-      "You modified files this turn but ran NO verification (no test/build/typecheck command succeeded). " +
-      "Run the narrowest command that proves your change works, then call done. " +
-      "If verification is genuinely not applicable (docs/config-only change), call done again and say why in the reason.",
+      "You modified files this turn but have no passing verification (no test/build/typecheck command succeeded, or the latest recognized verification failed). " +
+      "Run the narrowest command that proves your change works, then call done.",
   };
 }

package/src/agent/notify/daemon-control.ts

@@ -15,6 +15,8 @@ import { readGlobalConfig } from "../state";
 export interface DaemonLockInfo {
   pid: number;
   startedAt: number;
+  purpose?: "daemon" | "pairing";
+  ready?: boolean;
 }
 
 export function isPidAlive(pid: number): boolean {
@@ -152,32 +154,87 @@ export async function readDaemonLock(): Promise<DaemonLockInfo | undefined> {
     const raw = await fs.readFile(notifyDaemonLockPath(), "utf-8");
     const parsed = JSON.parse(raw) as Partial<DaemonLockInfo>;
     if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "number") return undefined;
-    return { pid: parsed.pid, startedAt: parsed.startedAt };
+    if (!Number.isSafeInteger(parsed.pid) || parsed.pid <= 0 || !Number.isFinite(parsed.startedAt)) return undefined;
+    return { pid: parsed.pid, startedAt: parsed.startedAt, purpose: parsed.purpose, ready: parsed.ready };
   } catch {
     return undefined;
   }
 }
 
-/** Called by the daemon process itself on startup. Returns `undefined` when a
- *  live owner already holds the lock (caller must exit without polling
- *  Telegram); otherwise writes the lock and returns a `release()` closure. */
-export async function acquireDaemonLock(): Promise<{ release: () => Promise<void> } | undefined> {
+async function interruptedRecoveryMessage(): Promise<string | undefined> {
+  const guard = `${notifyDaemonLockPath()}.reclaim`;
+  const stat = await fs.stat(guard).catch(() => undefined);
+  if (stat && Date.now() - stat.mtimeMs >= 30_000) {
+    return `Notification lock recovery is blocked by ${guard}. Stop all daemon/pairing processes and verify their owners are gone before manually removing this recovery guard; it is not automatically deleted because that can race a live lock owner.`;
+  }
+  return undefined;
+}
+
+/** Exclusive process lock shared with Telegram pairing, which also owns getUpdates. */
+export async function acquireDaemonLock(purpose: "daemon" | "pairing" = "daemon"): Promise<{ release: () => Promise<void>; markReady: () => Promise<void> } | undefined> {
   await fs.mkdir(notifyDir(), { recursive: true, mode: 0o700 });
-  const existing = await readDaemonLock();
-  if (existing && existing.pid !== process.pid && (await isLockOwnerAlive(existing))) return undefined;
-  const info: DaemonLockInfo = { pid: process.pid, startedAt: Date.now() };
-  await fs.writeFile(notifyDaemonLockPath(), JSON.stringify(info), { mode: 0o600 });
+  const lockPath = notifyDaemonLockPath();
+  let contents = JSON.stringify({ pid: process.pid, startedAt: await processStartTimeMs(process.pid) ?? Date.now(), purpose, ready: false, owner: crypto.randomUUID() });
+  const create = async () => {
+    // Publish a fully written record atomically; a killed writer cannot leave partial JSON.
+    const tmp = `${lockPath}.${crypto.randomUUID()}.tmp`;
+    try {
+      await fs.writeFile(tmp, contents, { mode: 0o600, flag: "wx" });
+      await fs.link(tmp, lockPath);
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "EEXIST") return false;
+      throw error;
+    } finally { await fs.unlink(tmp).catch(() => {}); }
+  };
+  if (!(await create())) {
+    // Serialize stale-owner reclamation so a second contender cannot unlink the winner.
+    let reclaim: fs.FileHandle;
+    try { reclaim = await fs.open(`${lockPath}.reclaim`, "wx", 0o600); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "EEXIST") {
+        const blocked = await interruptedRecoveryMessage();
+        if (blocked) throw new Error(blocked);
+        return undefined;
+      }
+      throw error;
+    }
+    try {
+      const existing = await readDaemonLock();
+      if (existing && await isLockOwnerAlive(existing)) return undefined;
+      // Recover legacy malformed locks only after a grace period for old writers.
+      if (!existing && Date.now() - (await fs.stat(lockPath)).mtimeMs < 30_000) return undefined;
+      await fs.unlink(lockPath);
+      if (!(await create())) return undefined;
+    } finally {
+      await reclaim.close();
+      await fs.unlink(`${lockPath}.reclaim`).catch(() => {});
+    }
+  }
   return {
+    markReady: async () => {
+      if (await fs.readFile(lockPath, "utf-8").catch(() => "") !== contents) throw new Error("Notification daemon lost lock ownership during startup");
+      const next = JSON.stringify({ ...JSON.parse(contents), ready: true });
+      const tmp = `${lockPath}.${crypto.randomUUID()}.tmp`;
+      try {
+        await fs.writeFile(tmp, next, { mode: 0o600, flag: "wx" });
+        await fs.rename(tmp, lockPath);
+        contents = next;
+      } finally { await fs.unlink(tmp).catch(() => {}); }
+    },
     release: async () => {
-      await fs.unlink(notifyDaemonLockPath()).catch(() => {});
+      // An old release closure must not remove a newer owner's lock.
+      if (await fs.readFile(lockPath, "utf-8").catch(() => "") === contents) await fs.unlink(lockPath).catch(() => {});
     },
   };
 }
 
 export interface DaemonStatus {
-  /** `notifications.enabled` + a stored bot token + chat id are all present. */
+  /** Master toggle and at least one complete, authorized transport. */
   configured: boolean;
   running: boolean;
+  pairing?: boolean;
+  ready?: boolean;
   /** A lock file exists but its pid is dead — a previous daemon crashed without cleanup. */
   stale: boolean;
   pid?: number;
@@ -190,7 +247,12 @@ export interface DaemonStatus {
 
 export async function isNotifyConfigured(): Promise<boolean> {
   const config = await readGlobalConfig();
-  return Boolean(config.notifications?.enabled && config.notifications.telegram?.botToken && config.notifications.telegram?.chatId);
+  const n = config.notifications;
+  return Boolean(n?.enabled && (
+    (n.telegram?.botToken && n.telegram.chatId) ||
+    (n.discord?.botToken && n.discord.channelId && n.discord.allowedUserIds?.length) ||
+    (n.slack?.botToken && n.slack.appToken && n.slack.channelId && n.slack.allowedUserIds?.length)
+  ));
 }
 
 export async function daemonStatus(): Promise<DaemonStatus> {
@@ -199,7 +261,7 @@ export async function daemonStatus(): Promise<DaemonStatus> {
   const { alive, verified } = await inspectLockOwner(lock);
   // Surface the degraded case instead of hiding it: on a host with no `/proc` and no
   // usable `ps`, "running" is an existence-only guess that cannot rule out PID reuse.
-  return { configured, running: alive, stale: !alive, pid: lock.pid, startedAt: lock.startedAt, ownerVerified: verified };
+  return { configured, running: alive && lock.purpose !== "pairing", pairing: alive && lock.purpose === "pairing", ready: alive && lock.ready === true, stale: !alive, pid: lock.pid, startedAt: lock.startedAt, ownerVerified: verified };
 }
 
 /** Self-invocation argv for the daemon child (mirrors `memory.ts`'s
@@ -240,10 +302,11 @@ async function waitFor(predicate: () => Promise<boolean>, timeoutMs: number, ste
   return false;
 }
 
-export async function startDaemon(spawnImpl: SpawnLike = defaultSpawn): Promise<{ ok: boolean; pid?: number; message: string }> {
+export async function startDaemon(spawnImpl: SpawnLike = defaultSpawn, waitImpl: (predicate: () => Promise<boolean>, timeoutMs: number) => Promise<boolean> = waitFor): Promise<{ ok: boolean; pid?: number; message: string }> {
   const existing = await readDaemonLock();
   if (existing && (await isLockOwnerAlive(existing))) {
-    return { ok: true, pid: existing.pid, message: `daemon already running (pid ${existing.pid})` };
+    if (existing.purpose === "pairing") return { ok: false, message: "Telegram pairing currently owns the notification lock; finish setup first." };
+    return { ok: existing.ready === true, pid: existing.pid, message: `daemon ${existing.ready !== true ? "is still initializing" : "already running"} (pid ${existing.pid}); connectivity not checked` };
   }
   // Check BEFORE spawning: an unconfigured daemon exits almost immediately (see
   // `runNotifyDaemonForeground`), which races the readiness poll below and used to
@@ -252,24 +315,45 @@ export async function startDaemon(spawnImpl: SpawnLike = defaultSpawn): Promise<
     return { ok: false, message: "notifications not configured — run 'jeo notify setup' first." };
   }
 
+  const blocked = await interruptedRecoveryMessage();
+  if (blocked) return { ok: false, message: blocked };
+
   const cmd = daemonInvocation(process.argv[1], process.execPath, process.cwd());
   spawnImpl(cmd, process.cwd()).unref();
-  const ready = await waitFor(async () => {
+  const ready = await waitImpl(async () => {
     const lock = await readDaemonLock();
-    return Boolean(lock && isPidAlive(lock.pid));
-  }, 2_000);
-  if (!ready) return { ok: false, message: `daemon did not report ready within 2s — check ${notifyDaemonLogPath()}` };
+    return Boolean(lock && lock.purpose === "daemon" && lock.ready === true && isPidAlive(lock.pid));
+  }, 15_000);
+  if (!ready) return { ok: false, message: `daemon did not initialize within 15s — check ${notifyDaemonLogPath()}` };
   const lock = await readDaemonLock();
-  return { ok: true, pid: lock?.pid, message: `daemon started (pid ${lock?.pid})` };
+  return { ok: true, pid: lock?.pid, message: `daemon initialized (pid ${lock?.pid}); use notify health to check platform access` };
+}
+
+async function removeStoppedLock(expected: DaemonLockInfo): Promise<void> {
+  const lockPath = notifyDaemonLockPath();
+  let guard: fs.FileHandle;
+  try { guard = await fs.open(`${lockPath}.reclaim`, "wx", 0o600); }
+  catch (error) {
+    if (["EEXIST", "ENOENT"].includes((error as NodeJS.ErrnoException).code ?? "")) return;
+    throw error;
+  }
+  try {
+    const current = await readDaemonLock();
+    if (current?.pid === expected.pid && current.startedAt === expected.startedAt && !(await isLockOwnerAlive(current))) await fs.unlink(lockPath).catch(() => {});
+  } finally {
+    await guard.close();
+    await fs.unlink(`${lockPath}.reclaim`).catch(() => {});
+  }
 }
 
 export async function stopDaemon(): Promise<{ ok: boolean; message: string }> {
   const lock = await readDaemonLock();
   const owner = lock ? await inspectLockOwner(lock) : undefined;
   if (!lock || !owner?.alive) {
-    await fs.unlink(notifyDaemonLockPath()).catch(() => {});
+    if (lock) await removeStoppedLock(lock);
     return { ok: true, message: "daemon was not running" };
   }
+  if (lock.purpose === "pairing") return { ok: false, message: "Telegram pairing is active; cancel setup in its terminal first." };
   try {
     process.kill(lock.pid, "SIGTERM");
   } catch (err) {
@@ -277,13 +361,14 @@ export async function stopDaemon(): Promise<{ ok: boolean; message: string }> {
   }
   const stopped = await waitFor(async () => !isPidAlive(lock.pid), 3_000);
   if (!stopped) return { ok: false, message: `daemon (pid ${lock.pid}) did not exit within 3s` };
-  await fs.unlink(notifyDaemonLockPath()).catch(() => {});
+  await removeStoppedLock(lock);
   const caveat = owner.verified ? "" : " (start time unverifiable on this host — PID reuse could not be ruled out)";
   return { ok: true, message: `daemon stopped (was pid ${lock.pid})${caveat}` };
 }
 
-export async function reloadDaemon(spawnImpl: SpawnLike = defaultSpawn): Promise<{ ok: boolean; message: string }> {
-  const stopRes = await stopDaemon();
+export async function reloadDaemon(spawnImpl: SpawnLike = defaultSpawn, stopImpl: typeof stopDaemon = stopDaemon): Promise<{ ok: boolean; message: string }> {
+  const stopRes = await stopImpl();
+  if (!stopRes.ok) return stopRes;
   const startRes = await startDaemon(spawnImpl);
   return { ok: startRes.ok, message: `${stopRes.message}; ${startRes.message}` };
 }