@synaplink/orqlaude 0.10.3 → 0.10.7

package/README.md

@@ -183,6 +183,171 @@ User says: *"Refactor the auth system — magic-link login, update the docs, add
 8. `orqlaude.collect` → three PR URLs and summaries.
 9. **NEW**: `orqlaude.review_prs(plan_id)` → spawns three reviewer agents, one per PR. Each reviews, runs tests, posts findings. You aggregate the second-round notes.
 
+## Asking the user (v0.10.4 pattern)
+
+`ask_user` and its companion `wait_for_user_response` are the bounded-block loop primary Claude uses to put a question on Telegram and stay alive past the MCP host's 60s per-request timeout.
+
+The split exists because Claude Desktop and Claude Code both use the SDK default `DEFAULT_REQUEST_TIMEOUT_MSEC = 60000`. v0.10.2's progress notifications turned out to be ignored unless the client passes `resetTimeoutOnProgress: true` (it doesn't), so a single blocking call can't outrun the host. Instead, `ask_user` blocks at most 45s (the new `initial_block_sec`, capped at 45). The question's overall lifetime is `total_timeout_sec` (default 900s, max 3600s) -- that's how long it stays answerable. If the user replies inside the first window, you get `status: "answered"`. Otherwise you get `status: "still_pending"` with a `short_id`, and the caller must invoke `wait_for_user_response(short_id)` to keep waiting.
+
+Loop pattern (TS pseudocode):
+
+```ts
+let result = await ask_user({
+  prompt: "Approve the auth refactor plan?",
+  options: ["Approve", "Hold off"],
+  total_timeout_sec: 1800,
+});
+
+while (result.status === "still_pending") {
+  result = await wait_for_user_response({ short_id: result.short_id });
+}
+// result.status is now "answered" / "timed_out" / "cancelled"
+```
+
+Each call stays safely under 60s. A fast answer is one round-trip; a 5-minute wait is roughly 7 round-trips, no `ScheduleWakeup`-and-come-back required.
+
+Telegram side is plain text only (no Markdown), so escaping bugs can't silently swallow a send. The notifier ships each question with `force_reply` enabled -- the user just types and their reply carries `reply_to_message.message_id`, which the bot matches back to the request. Inline-keyboard buttons fire the same answer path when `options` are provided; `/respond <short_id> <text>` remains as a manual fallback.
+
+## Autopilot daemon
+
+A persistent orchestrator that ticks every 10 seconds, picks goals off the backlog, auto-reviews PRs, retries failed Agnets, and watches the budget. Opt-in -- nothing runs in the background unless you start it.
+
+Five tick-loop phases:
+
+1. **Reconcile state** -- for every spawned Agnet, refresh from JSONL, PID, and exit-record; promote `died_at_launch` / `done` / `failed`.
+2. **Recover from failures** -- classify each failure via a Plan-billed `claude -p` turn, then retry with backoff, spawn a debugger Agnet, or escalate to the user via Telegram.
+3. **Auto-review PRs** -- fetch the diff, run a reviewer turn, apply the fleet template's auto-merge rule, and either `gh pr merge` or `gh pr comment`.
+4. **Pick the next goal** -- when the fleet is idle and autopilot is unpaused, pull the highest-priority unblocked goal from the backlog and prompt the user via Telegram.
+5. **Watch the budget** -- yellow / orange / red thresholds; auto-pause at orange.
+
+CLI:
+
+```sh
+orql autopilot start            # foreground; daemonize with launchd / systemd / nohup
+orql autopilot stop
+orql autopilot pause            # stop picking new work; in-flight Agnets keep running
+orql autopilot resume
+orql autopilot status
+```
+
+Plan-billing note: the daemon **never** talks to the Anthropic API. Every intelligent decision (failure classifier, PR reviewer, Telegram intent classifier, template suggester) is a `claude -p` invocation. On the Max plan that bills like an interactive Claude Code session, and cache reads are free, so a full day of ticking burns a tiny fraction of quota.
+
+## Durable memory
+
+A `memory.json` file at `<state_dir>/memory.json` holds long-lived facts that outlive plan lifecycles. Four spirit-themed categories, each with a different surfacing rule:
+
+- **lore** -- facts about the user. Pinned, slow churn, injected into every spawned Agnet prompt. _Example: "Russian comments in CRM templates", "no auto-deploy on Fridays."_
+- **playbook** -- code conventions. Scope-tagged by path-glob; injected when a fleet's scope overlaps. _Example: "migrations live in `<app>/migrations/`", "use AntD ConfigProvider for dark mode."_
+- **ledger** -- decisions plus rationale. Append-only; surfaced when a similar decision recurs. _Example: "Sonnet over Opus for transcription, latency mattered more than depth."_
+- **atlas** -- project map. Auto-updated by the post-PR review with one entry per touched file mapping path to purpose.
+
+Pinned entries always load. Scope-tagged entries (typically playbook and atlas) auto-inject into a spawn prompt when the Agnet's worktree scope matches any of the entry's globs -- you don't have to remember to thread conventions through manually.
+
+MCP tools:
+
+```
+remember(category, key, value, { pinned?, scopeGlobs?, rationale? })
+recall(category?, key?, scopeMatch?)
+forget(category, key)
+compose_memory_context(scopeGlobs?, max_tokens?)
+```
+
+Older entries with the same `(category, key)` are soft-superseded: kept for history but invisible to read paths. `compose_memory_context` is the function the spawn pipeline uses internally; call it directly to preview the block that will be injected for a given scope before you commit to spawning.
+
+## Backlog
+
+A `backlog.json` file holds `Goal` records -- durable task descriptions the daemon (or you) can pick from when idle.
+
+Shape:
+
+```json
+{
+  "id": "g_8f3...",
+  "title": "Rotate JWT signing keys quarterly",
+  "priority": 70,
+  "deadlineAt": "2026-06-30T00:00:00Z",
+  "dependsOn": ["g_5c1..."],
+  "createdAt": "2026-05-12T10:14:00Z",
+  "status": "pending"
+}
+```
+
+Priority is 0-100. `deadlineAt` boosts effective priority as the deadline approaches (linear ramp over the last 14 days, so something due tomorrow with priority 40 beats a no-deadline priority 70 item). `dependsOn` is a list of goal ids; a goal is blocked until every parent has `status: "done"`.
+
+MCP tools:
+
+```
+enqueue_goal(title, { priority?, deadlineAt?, dependsOn?, source? })
+list_goals({ status?, includeBlocked? })
+update_goal(id, { priority?, deadlineAt?, dependsOn?, status? })
+pick_next_goal()
+```
+
+`pick_next_goal` returns the highest-priority unblocked pending goal, factoring in deadline boost. The autopilot daemon calls this on every idle tick; when something comes back it surfaces the goal to the user via Telegram for confirmation before spawning a fleet, so you keep approval-in-the-loop even when the orchestrator is running unattended.
+
+## Fleet templates
+
+Eight named patterns ship out of the box. Each defines a default Agnet layout, a suggested model per role (haiku / sonnet / opus), a default budget, and an `AutoMergeRule` the daemon applies to PRs produced by the fleet.
+
+| id | what it does | auto-merge rule |
+|---|---|---|
+| `backend-feature` | Django/DRF: model + migration + serializer + viewset + admin + tests | requireCi, maxLoc 2500 |
+| `frontend-feature` | React/AntD: components + hooks + i18n + tests | requireCi, maxLoc 2000 |
+| `migration-only` | Schema change with backwards-compat reviewer (opus) | requireReviewerApprove; `blockOnMigrations: false` (migrations are the point) |
+| `audit-sweep` | Multiple haiku auditors + sonnet synthesizer (read-only) | requireReviewerApprove (no merge) |
+| `dep-upgrade` | Dep version bump + breaking-change patches + reviewer | requireCi, requireReviewerApprove |
+| `i18n-pass` | Audit, then translator pass | requireCi, maxLoc 3000 |
+| `test-coverage-fill` | Parallel testers; blocks PRs that touch prod code | requireCi, blockOnPaths globs for non-test files |
+| `bug-hunt` | Reproducer Agnet then fixer Agnet (sequential) | requireReviewerApprove, requireCi |
+
+MCP tools:
+
+```
+list_fleet_templates()
+suggest_fleet_template(goal_text)    # Plan-billed turn picks the best fit
+apply_fleet_template(template_id, { goal, scope, budget_override? })
+```
+
+`suggest_fleet_template` makes a single `claude -p` call that returns `{ template_id, confidence, reason }`. The autopilot daemon uses this to turn a freeform goal description into a concrete fleet definition without manual plan authoring. `apply_fleet_template` then expands the chosen template into a real plan via `create_plan`, with the template's auto-merge rule attached for later use by the auto-review pipeline.
+
+## Auto-PR-review
+
+When the autopilot daemon is running, every PR produced by a template-driven fleet gets a reviewer turn and an auto-merge attempt.
+
+The reviewer turn runs `gh pr view` for the diff and metadata, feeds them into a strict-JSON `claude -p` prompt, and parses the response `{ verdict, blockers, suggestions, summary }` where `verdict` is `APPROVE` / `REQUEST_CHANGES` / `COMMENT`. The summary is appended as a PR comment regardless of verdict so you have a paper trail.
+
+The fleet template's `AutoMergeRule` then decides whether to merge:
+
+```json
+{
+  "requireReviewerApprove": true,
+  "requireCi": true,
+  "maxLoc": 2500,
+  "blockOnMigrations": false,
+  "blockOnPaths": ["**/settings.py", "**/secrets/**"]
+}
+```
+
+- `requireReviewerApprove` -- the reviewer's verdict must be `APPROVE`.
+- `requireCi` -- `gh pr checks` must come back all-green.
+- `maxLoc` -- additions plus deletions under cap. Larger PRs route to user.
+- `blockOnMigrations` -- refuses PRs that add files under `*/migrations/` (used by templates that aren't supposed to touch schema).
+- `blockOnPaths` -- refuses PRs touching specific globs.
+
+If every check passes the daemon runs `gh pr merge --squash --auto --delete-branch`. Otherwise it `gh pr comment`s with the verdict and blockers and leaves the PR open. Each review writes a `ledger` memory entry so the next fleet inherits the rationale.
+
+## Cost guardrails
+
+A `guardrails.json` rolling ledger tracks billed tokens against two windows: a 5-hour rolling window (matching Anthropic's Plan reset cadence) and a per-local-day soft cap (default 30M billed tokens).
+
+Three threshold bands on the rolling window:
+
+- **yellow** at 60% -- notify the user, daemon slows inter-tick interval.
+- **orange** at 80% -- daemon auto-pauses; refuses to start new fleets; in-flight Agnets keep running but no new spawns happen.
+- **red** at 95% -- halt entirely; await user `/resume` after the next 5h reset.
+
+The day soft-cap applies independently of the rolling window -- you can sit comfortably in green on the 5h window and still cross the day cap if you've been running multiple windows back to back. Both checks happen on every autopilot tick, and the orange auto-pause uses the same code path as `orql autopilot pause`: it surfaces in `orql autopilot status` and is undone with `orql autopilot resume` once the window has rolled.
+
 ## State
 
 orqlaude resolves its state directory at startup using this order (first match wins):

package/dist/__tests__/v0105.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/v0105.test.js

@@ -0,0 +1,94 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+/**
+ * v0.10.5 — spawn_via_cli pre-allocates session_id and embeds it in the
+ * fleet protocol prompt + checkin handler accepts rotation for freshly
+ * spawned tasks.
+ *
+ * Bug it fixes: orqlaude self-test fleet d47c0448 — Verdant tried to
+ * checkin with $CLAUDE_CODE_SESSION_ID (Claude Code's internal value)
+ * which differed from the --session-id flag orqlaude passed. The
+ * pre-allocation had already filled task.spawnedSessionId so
+ * unclaimedTaskById returned undefined, falling through to
+ * task_already_claimed rejection.
+ */
+async function tempDir(label) {
+    return fs.mkdtemp(path.join(os.tmpdir(), `orqlaude-v0105-${label}-`));
+}
+test("v0.10.5: spawn_via_cli sessionId override flows through to --session-id flag", async () => {
+    // Verify the SpawnViaCliInput.sessionId field is honored. We can't actually
+    // spawn claude in unit tests (no binary), but we can confirm the type +
+    // pass-through logic by reading the source.
+    // import.meta.dirname under built dist/__tests__/ → ../../src/lib/spawn_cli.ts
+    // import.meta.dirname under built dist/__tests__/ → ../../src/lib/spawn_cli.ts
+    const src = await fs.readFile(path.join(import.meta.dirname, "..", "..", "src", "lib", "spawn_cli.ts"), "utf8");
+    // The fallback `?? randomUUID()` should be present so omitted sessionId
+    // still produces a uuid.
+    assert.ok(src.includes("input.sessionId ?? randomUUID()"), "sessionId fallback wiring missing");
+    assert.ok(src.includes("sessionId?:"), "sessionId field missing from SpawnViaCliInput");
+});
+test("v0.10.5: checkin accepts session-id rotation for freshly spawned tasks", async () => {
+    // Simulate the v0.10.4-and-earlier failure mode + verify v0.10.5 handles it.
+    const dir = await tempDir("checkin-rotate");
+    // Build a minimal state file with a pre-allocated spawnedSessionId.
+    const stateFile = path.join(dir, "orqlaude-state.json");
+    const planId = "plan-test-id-fixed";
+    const taskId = "task-test-id-fixed";
+    const preallocatedSessionId = "preallocated-session-id";
+    const agentSessionId = "agent-different-session-id";
+    const justStartedAt = Date.now() - 5_000; // 5s ago - within 60s grace
+    await fs.writeFile(stateFile, JSON.stringify({
+        schemaVersion: 3,
+        plans: {
+            [planId]: {
+                id: planId,
+                createdAt: Date.now(),
+                rootTask: "test",
+                budgetCapTokens: 1000,
+                perAgentCapTokens: 1000,
+                status: "running",
+                tasks: [
+                    {
+                        id: taskId,
+                        title: "t",
+                        prompt: "p",
+                        tldr: "t",
+                        status: "running",
+                        spawnedSessionId: preallocatedSessionId,
+                        startedAt: justStartedAt,
+                    },
+                ],
+                notes: [],
+                messages: [],
+                claims: [],
+                userNotifications: [],
+                userResponseRequests: [],
+                userStreams: [],
+            },
+        },
+    }));
+    // We can't easily call the registered tool callback directly (it's wrapped
+    // through MCP). But we CAN verify the broker.ts source contains the
+    // rotation logic by reading it.
+    const brokerSrc = await fs.readFile(path.join(import.meta.dirname, "..", "..", "src", "tools", "broker.ts"), "utf8");
+    assert.ok(brokerSrc.includes("wasJustSpawned"), "broker.ts should have the wasJustSpawned rotation check");
+    assert.ok(brokerSrc.includes("noNotesYet"), "broker.ts should also gate rotation on no-notes-yet");
+    assert.ok(brokerSrc.includes("60_000"), "broker.ts should use 60s grace window for rotation");
+});
+test("v0.10.5: buildSpawnPrompt embeds session_id when provided", async () => {
+    // Pure source-level check that the prompt builder honors the sessionId arg.
+    const dispatchSrc = await fs.readFile(path.join(import.meta.dirname, "..", "..", "src", "tools", "dispatch.ts"), "utf8");
+    assert.ok(dispatchSrc.includes("sessionId?: string"), "buildSpawnPrompt should accept optional sessionId");
+    assert.ok(dispatchSrc.includes("EXACT value, pre-allocated by orqlaude"), "When sessionId is provided, the prompt should instruct the agent to use it exactly");
+    assert.ok(dispatchSrc.includes("NOT $CLAUDE_CODE_SESSION_ID"), "The protocol prompt should explicitly tell the agent NOT to use the env var");
+});
+test("v0.10.5: spawn_via_cli handler pre-generates session_id before buildSpawnPrompt", async () => {
+    const dispatchSrc = await fs.readFile(path.join(import.meta.dirname, "..", "..", "src", "tools", "dispatch.ts"), "utf8");
+    assert.ok(dispatchSrc.includes("presetSessionId = randomUUID()"), "spawn_via_cli handler should pre-allocate session_id with randomUUID");
+    assert.ok(/buildSpawnPrompt\([^)]*presetSessionId\)/.test(dispatchSrc), "presetSessionId should be passed into buildSpawnPrompt");
+    assert.ok(/sessionId:\s*presetSessionId/.test(dispatchSrc), "presetSessionId should be passed into spawnAgnetViaCli as sessionId");
+});
+//# sourceMappingURL=v0105.test.js.map

package/dist/__tests__/v0105.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"v0105.test.js","sourceRoot":"","sources":["../../src/__tests__/v0105.test.ts"],"names":[],"mappings":"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"}

package/dist/__tests__/v0107.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/v0107.test.js

@@ -0,0 +1,37 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+/**
+ * v0.10.7 — re-spawn hygiene.
+ *
+ * Bugs surfaced during the Verdant re-spawn in self-test fleet d47c0448:
+ *
+ *   1. `.orqlaude.exit.json` from a prior agent stayed on disk and made
+ *      `snapshot()` report the new agent as already terminated.
+ *   2. `task.stopRequested` set by kill_task survived re-spawn, so the
+ *      new agent's first checkin received a stale HARD STOP and bailed.
+ *
+ * Both fixed via source-level surgery. These tests verify the surgery is
+ * present (the actual spawn path needs an integration test with claude).
+ */
+test("v0.10.7: spawn_cli unlinks stale .orqlaude.exit.json before spawn", async () => {
+    const src = await fs.readFile(path.join(import.meta.dirname, "..", "..", "src", "lib", "spawn_cli.ts"), "utf8");
+    assert.ok(src.includes("exitJsonPathPre"), "spawn_cli should pre-unlink the exit json with a named variable");
+    assert.ok(/fs\.unlink\(exitJsonPathPre\)/.test(src), "spawn_cli should actually attempt to unlink the prior exit json");
+    assert.ok(src.indexOf("exitJsonPathPre") < src.indexOf("spawn(claudeBin"), "the pre-unlink must happen BEFORE the new process is spawned");
+});
+test("v0.10.7: spawn_via_cli handler clears task.stopRequested on re-spawn", async () => {
+    const src = await fs.readFile(path.join(import.meta.dirname, "..", "..", "src", "tools", "dispatch.ts"), "utf8");
+    assert.ok(src.includes("task.stopRequested = undefined"), "spawn_via_cli should reset stopRequested when claiming a previously-killed task");
+    assert.ok(src.includes("task.finishedAt = undefined"), "spawn_via_cli should also clear finishedAt so status() doesn't think the new run is terminated");
+    assert.ok(src.includes("task.exitReason = undefined"), "spawn_via_cli should also clear exitReason from the prior run");
+});
+test("v0.10.7: clears happen AFTER setting new spawnedSessionId / pid", async () => {
+    const src = await fs.readFile(path.join(import.meta.dirname, "..", "..", "src", "tools", "dispatch.ts"), "utf8");
+    const idxSpawnedId = src.indexOf("task.spawnedSessionId = spawn.sessionId");
+    const idxStopClear = src.indexOf("task.stopRequested = undefined");
+    assert.ok(idxSpawnedId > 0 && idxStopClear > 0, "both lines must be present");
+    assert.ok(idxStopClear > idxSpawnedId, "clearing stopRequested must come AFTER setting the new spawnedSessionId to avoid losing the new claim if a concurrent reader sees the intermediate state");
+});
+//# sourceMappingURL=v0107.test.js.map

package/dist/__tests__/v0107.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"v0107.test.js","sourceRoot":"","sources":["../../src/__tests__/v0107.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B;;;;;;;;;;;;GAYG;AAEH,IAAI,CAAC,mEAAmE,EAAE,KAAK,IAAI,EAAE;IACnF,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,QAAQ,CAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,cAAc,CAAC,EACxE,MAAM,CACP,CAAC;IACF,MAAM,CAAC,EAAE,CACP,GAAG,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAC/B,iEAAiE,CAClE,CAAC;IACF,MAAM,CAAC,EAAE,CACP,+BAA+B,CAAC,IAAI,CAAC,GAAG,CAAC,EACzC,iEAAiE,CAClE,CAAC;IACF,MAAM,CAAC,EAAE,CACP,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAC/D,8DAA8D,CAC/D,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,sEAAsE,EAAE,KAAK,IAAI,EAAE;IACtF,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,QAAQ,CAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC,EACzE,MAAM,CACP,CAAC;IACF,MAAM,CAAC,EAAE,CACP,GAAG,CAAC,QAAQ,CAAC,gCAAgC,CAAC,EAC9C,iFAAiF,CAClF,CAAC;IACF,MAAM,CAAC,EAAE,CACP,GAAG,CAAC,QAAQ,CAAC,6BAA6B,CAAC,EAC3C,gGAAgG,CACjG,CAAC;IACF,MAAM,CAAC,EAAE,CACP,GAAG,CAAC,QAAQ,CAAC,6BAA6B,CAAC,EAC3C,+DAA+D,CAChE,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,iEAAiE,EAAE,KAAK,IAAI,EAAE;IACjF,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,QAAQ,CAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC,EACzE,MAAM,CACP,CAAC;IACF,MAAM,YAAY,GAAG,GAAG,CAAC,OAAO,CAAC,yCAAyC,CAAC,CAAC;IAC5E,MAAM,YAAY,GAAG,GAAG,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAC;IACnE,MAAM,CAAC,EAAE,CAAC,YAAY,GAAG,CAAC,IAAI,YAAY,GAAG,CAAC,EAAE,4BAA4B,CAAC,CAAC;IAC9E,MAAM,CAAC,EAAE,CACP,YAAY,GAAG,YAAY,EAC3B,0JAA0J,CAC3J,CAAC;AACJ,CAAC,CAAC,CAAC"}

package/dist/__tests__/v010_helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/v010_helpers.test.js

@@ -0,0 +1,301 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { tryParseJson, extractAssistantText } from "../lib/orch_turn.js";
+import { classifyFailure, countRetries, readTail, DEFAULT_RETRY } from "../lib/retry.js";
+import { applyRule } from "../lib/auto_merge.js";
+import { parseSlashCommand } from "../lib/tg_classifier.js";
+/**
+ * v0.10.x helper coverage - JSON extraction, retry classifier fast paths,
+ * auto-merge edge cases, slash-command parser corners. Sibling to v010.test.ts;
+ * these focus on internal helpers and edge cases the higher-level tests skip.
+ */
+async function tempDir(label) {
+    return fs.mkdtemp(path.join(os.tmpdir(), `orqlaude-v010h-${label}-`));
+}
+// ---- orch_turn.tryParseJson ---------------------------------------------
+test("v0.10.x: tryParseJson parses plain JSON object", () => {
+    const r = tryParseJson('{"a":1,"b":"two"}');
+    assert.equal(r.ok, true);
+    if (r.ok)
+        assert.deepEqual(r.value, { a: 1, b: "two" });
+});
+test("v0.10.x: tryParseJson strips ```json ... ``` fences", () => {
+    const r = tryParseJson('```json\n{"action":"retry"}\n```');
+    assert.equal(r.ok, true);
+    if (r.ok)
+        assert.deepEqual(r.value, { action: "retry" });
+});
+test("v0.10.x: tryParseJson strips bare ``` ... ``` fences", () => {
+    const r = tryParseJson('```\n{"x":42}\n```');
+    assert.equal(r.ok, true);
+    if (r.ok)
+        assert.deepEqual(r.value, { x: 42 });
+});
+test("v0.10.x: tryParseJson lifts the first {...} out of surrounding prose", () => {
+    const text = 'Sure, here is the JSON you asked for:\n{"verdict":"APPROVE","blockers":[]}\nLet me know if you need more.';
+    const r = tryParseJson(text);
+    assert.equal(r.ok, true);
+    if (r.ok)
+        assert.deepEqual(r.value, { verdict: "APPROVE", blockers: [] });
+});
+test("v0.10.x: tryParseJson handles nested objects (depth tracking)", () => {
+    const text = 'reasoning... {"outer":{"inner":{"k":1}},"arr":[1,2,3]} trailing prose';
+    const r = tryParseJson(text);
+    assert.equal(r.ok, true);
+    if (r.ok)
+        assert.deepEqual(r.value, { outer: { inner: { k: 1 } }, arr: [1, 2, 3] });
+});
+test("v0.10.x: tryParseJson returns ok:false with error for empty input", () => {
+    const r = tryParseJson("");
+    assert.equal(r.ok, false);
+    if (!r.ok)
+        assert.match(r.error, /empty/i);
+});
+test("v0.10.x: tryParseJson returns ok:false when no '{' present", () => {
+    const r = tryParseJson("just some prose, no JSON to be found here");
+    assert.equal(r.ok, false);
+    if (!r.ok)
+        assert.match(r.error, /no JSON object/i);
+});
+test("v0.10.x: tryParseJson reports parse failure with offset for malformed object", () => {
+    const r = tryParseJson('{"a": 1, "b": ,}');
+    assert.equal(r.ok, false);
+    if (!r.ok)
+        assert.match(r.error, /JSON parse failed|offset/i);
+});
+test("v0.10.x: tryParseJson reports unbalanced braces", () => {
+    const r = tryParseJson('{"a": 1');
+    assert.equal(r.ok, false);
+    if (!r.ok)
+        assert.ok(r.error.length > 0);
+});
+// ---- orch_turn.extractAssistantText -------------------------------------
+test("v0.10.x: extractAssistantText concatenates assistant.message.content text blocks", () => {
+    const env = { type: "assistant", message: { content: [{ type: "text", text: "hello " }, { type: "text", text: "world" }] } };
+    const out = extractAssistantText(JSON.stringify(env));
+    assert.equal(out, "hello world");
+});
+test("v0.10.x: extractAssistantText handles {type:'text', text:'...'} envelope", () => {
+    const out = extractAssistantText(JSON.stringify({ type: "text", text: "plain text envelope" }));
+    assert.equal(out, "plain text envelope");
+});
+test("v0.10.x: extractAssistantText handles {type:'message_delta', delta:{text:'...'}} envelope", () => {
+    const lines = [
+        JSON.stringify({ type: "message_delta", delta: { text: "part one " } }),
+        JSON.stringify({ type: "message_delta", delta: { text: "part two" } }),
+    ].join("\n");
+    assert.equal(extractAssistantText(lines), "part one part two");
+});
+test("v0.10.x: extractAssistantText handles {type:'result', result:'...'} envelope", () => {
+    const out = extractAssistantText(JSON.stringify({ type: "result", result: "final answer" }));
+    assert.equal(out, "final answer");
+});
+test("v0.10.x: extractAssistantText skips lines that aren't valid JSON", () => {
+    const stdout = [
+        "not json at all",
+        JSON.stringify({ type: "text", text: "ok" }),
+        "{not valid json either",
+    ].join("\n");
+    assert.equal(extractAssistantText(stdout), "ok");
+});
+test("v0.10.x: extractAssistantText returns empty string for blank stdout", () => {
+    assert.equal(extractAssistantText(""), "");
+    assert.equal(extractAssistantText("   \n\n  "), "");
+});
+test("v0.10.x: extractAssistantText ignores envelope shapes it doesn't recognize", () => {
+    const stdout = [
+        JSON.stringify({ type: "system", subtype: "init" }),
+        JSON.stringify({ type: "tool_use", name: "x" }),
+        JSON.stringify({ type: "text", text: "kept" }),
+    ].join("\n");
+    assert.equal(extractAssistantText(stdout), "kept");
+});
+test("v0.10.x: extractAssistantText concatenates a mixed stream", () => {
+    const stdout = [
+        JSON.stringify({ type: "system", subtype: "init" }),
+        JSON.stringify({ type: "assistant", message: { content: [{ type: "text", text: "A" }] } }),
+        JSON.stringify({ type: "text", text: "B" }),
+        JSON.stringify({ type: "message_delta", delta: { text: "C" } }),
+        JSON.stringify({ type: "result", result: "D" }),
+    ].join("\n");
+    assert.equal(extractAssistantText(stdout), "ABCD");
+});
+// ---- retry.classifyFailure (fast path) ----------------------------------
+function makeTask(overrides = {}) {
+    const base = {
+        id: "task-id",
+        title: "T",
+        prompt: "p",
+        tldr: "t",
+        status: "died_at_launch",
+    };
+    return { ...base, ...overrides };
+}
+test("v0.10.x: classifyFailure fast-path retries when died_at_launch + retries < cap", async () => {
+    const task = makeTask({ status: "died_at_launch", summary: "[retry 0/2]" });
+    const decision = await classifyFailure(task, "", "", DEFAULT_RETRY);
+    assert.equal(decision.action, "retry");
+    assert.equal(decision.retryAfterMs, DEFAULT_RETRY.retryBackoffMs);
+    assert.match(decision.reason, /1\/2/);
+});
+test("v0.10.x: classifyFailure fast-path retries on first failure (no [retry] marker)", async () => {
+    const task = makeTask({ status: "died_at_launch" });
+    const decision = await classifyFailure(task, "", "", DEFAULT_RETRY);
+    assert.equal(decision.action, "retry");
+});
+test("v0.10.x: classifyFailure escalates when died_at_launch + retries >= cap", async () => {
+    const task = makeTask({ status: "died_at_launch", summary: "[retry 2/2]" });
+    const decision = await classifyFailure(task, "", "", DEFAULT_RETRY);
+    assert.equal(decision.action, "escalate");
+    assert.match(decision.reason, /Exhausted/i);
+});
+test("v0.10.x: classifyFailure treats failed-without-startedAt as launch death", async () => {
+    const task = makeTask({ status: "failed", startedAt: undefined });
+    const decision = await classifyFailure(task, "", "", DEFAULT_RETRY);
+    assert.equal(decision.action, "retry");
+});
+test("v0.10.x: classifyFailure respects custom maxDiedAtLaunchRetries cap", async () => {
+    const cfg = { ...DEFAULT_RETRY, maxDiedAtLaunchRetries: 1 };
+    const taskUnder = makeTask({ status: "died_at_launch", summary: "[retry 0/1]" });
+    const taskOver = makeTask({ status: "died_at_launch", summary: "[retry 1/1]" });
+    assert.equal((await classifyFailure(taskUnder, "", "", cfg)).action, "retry");
+    assert.equal((await classifyFailure(taskOver, "", "", cfg)).action, "escalate");
+});
+// ---- retry.countRetries -------------------------------------------------
+test("v0.10.x: countRetries reads N from '[retry N/M]' summary marker", () => {
+    assert.equal(countRetries(makeTask({ summary: "[retry 0/2]" })), 0);
+    assert.equal(countRetries(makeTask({ summary: "did things [retry 3/5] more text" })), 3);
+});
+test("v0.10.x: countRetries returns 0 when no marker present", () => {
+    assert.equal(countRetries(makeTask({ summary: undefined })), 0);
+    assert.equal(countRetries(makeTask({ summary: "no marker here" })), 0);
+});
+// ---- retry.readTail -----------------------------------------------------
+test("v0.10.x: readTail returns empty string for undefined path", async () => {
+    assert.equal(await readTail(undefined, 1024), "");
+});
+test("v0.10.x: readTail returns empty string for missing file", async () => {
+    const dir = await tempDir("readtail-missing");
+    const out = await readTail(path.join(dir, "does-not-exist.log"), 1024);
+    assert.equal(out, "");
+});
+test("v0.10.x: readTail returns last N bytes of an existing file", async () => {
+    const dir = await tempDir("readtail-ok");
+    const file = path.join(dir, "log.txt");
+    await fs.writeFile(file, "0123456789ABCDEF"); // 16 bytes
+    assert.equal(await readTail(file, 4), "CDEF");
+    assert.equal(await readTail(file, 100), "0123456789ABCDEF"); // larger than file
+});
+// ---- auto_merge.applyRule edge cases ------------------------------------
+function makePr(overrides = {}) {
+    return {
+        number: 1,
+        url: "https://github.com/x/y/pull/1",
+        state: "OPEN",
+        title: "t",
+        author: "a",
+        headBranch: "h",
+        baseBranch: "b",
+        additions: 10,
+        deletions: 5,
+        changedFiles: 1,
+        files: [{ path: "src/foo.ts", additions: 10, deletions: 5 }],
+        checksStatus: "success",
+        mergeable: true,
+        ...overrides,
+    };
+}
+function makeReview(overrides = {}) {
+    return { verdict: "APPROVE", blockers: [], suggestions: [], summary: "ok", ...overrides };
+}
+test("v0.10.x: applyRule with all-undefined rule still enforces defaults (CI + reviewer)", () => {
+    // Defaults: requireReviewerApprove !== false → enforced. requireCi !== false → enforced.
+    // A green PR with APPROVE should still pass.
+    const d = applyRule(makePr(), makeReview(), {});
+    assert.equal(d.ok, true);
+    assert.equal(d.violations.length, 0);
+});
+test("v0.10.x: applyRule requireCi:false ignores CI status failure", () => {
+    const d = applyRule(makePr({ checksStatus: "failure" }), makeReview(), { requireCi: false });
+    assert.equal(d.ok, true, "no CI requirement -> CI failure must not block");
+});
+test("v0.10.x: applyRule requireReviewerApprove:false ignores BLOCKER verdict", () => {
+    const d = applyRule(makePr(), makeReview({ verdict: "BLOCKER", blockers: ["x"] }), { requireReviewerApprove: false });
+    assert.equal(d.ok, true);
+});
+test("v0.10.x: applyRule treats maxLoc=0 as 'no cap' (does not block)", () => {
+    const d = applyRule(makePr({ additions: 9999, deletions: 9999 }), makeReview(), { maxLoc: 0 });
+    assert.equal(d.ok, true, "maxLoc=0 should mean no LoC cap");
+    assert.ok(!d.violations.some((v) => v.includes("exceeds cap")));
+});
+test("v0.10.x: applyRule maxLoc undefined also means no cap", () => {
+    const d = applyRule(makePr({ additions: 9999, deletions: 9999 }), makeReview(), {});
+    assert.ok(!d.violations.some((v) => v.includes("exceeds cap")));
+});
+test("v0.10.x: applyRule blockOnPaths stops at the first matching glob (no accumulation)", () => {
+    const pr = makePr({
+        files: [
+            { path: "backend/settings.py", additions: 1, deletions: 0 },
+            { path: ".github/workflows/ci.yml", additions: 1, deletions: 0 },
+            { path: "infra/terraform/main.tf", additions: 1, deletions: 0 },
+        ],
+    });
+    const d = applyRule(pr, makeReview(), {
+        blockOnPaths: ["**/settings.py", "**/ci.yml", "infra/**"],
+    });
+    assert.equal(d.ok, false);
+    // Only the first matching glob's violation should be recorded; the loop
+    // breaks after the first hit.
+    const blockHits = d.violations.filter((v) => v.startsWith("block_on_paths:"));
+    assert.equal(blockHits.length, 1, "blockOnPaths must short-circuit on first hit");
+    assert.match(blockHits[0], /settings\.py/);
+});
+test("v0.10.x: applyRule blockOnMigrations only counts migrations with additions > 0", () => {
+    // Removing a migration file (additions:0) is allowed; only newly-added
+    // migrations trip the rule.
+    const pr = makePr({
+        files: [{ path: "backend/deals/migrations/0042_old.py", additions: 0, deletions: 30 }],
+    });
+    const d = applyRule(pr, makeReview(), { blockOnMigrations: true });
+    assert.ok(!d.violations.some((v) => v.includes("migration")), "deletion-only migration shouldn't block");
+});
+test("v0.10.x: applyRule reports REQUEST_CHANGES verdict separately from BLOCKER", () => {
+    const d = applyRule(makePr(), makeReview({ verdict: "REQUEST_CHANGES", suggestions: ["rename foo"] }), { requireReviewerApprove: true });
+    assert.equal(d.ok, false);
+    assert.ok(d.violations.some((v) => v.includes("REQUEST_CHANGES")));
+});
+// ---- tg_classifier.parseSlashCommand corners ----------------------------
+test("v0.10.x: parseSlashCommand tolerates leading + trailing whitespace", () => {
+    assert.deepEqual(parseSlashCommand("  /now  "), { cmd: "now" });
+    assert.deepEqual(parseSlashCommand("\t/queue\n"), { cmd: "queue" });
+});
+test("v0.10.x: parseSlashCommand is case-insensitive on the command head", () => {
+    assert.deepEqual(parseSlashCommand("/NOW"), { cmd: "now" });
+    assert.deepEqual(parseSlashCommand("/Pause"), { cmd: "pause" });
+    assert.deepEqual(parseSlashCommand("/MORNING"), { cmd: "morning" });
+});
+test("v0.10.x: parseSlashCommand returns null for unknown slash commands", () => {
+    assert.equal(parseSlashCommand("/foo"), null);
+    assert.equal(parseSlashCommand("/help"), null);
+    assert.equal(parseSlashCommand("/respondx ab12 hi"), null);
+});
+test("v0.10.x: parseSlashCommand /respond requires both shortId and text", () => {
+    assert.equal(parseSlashCommand("/respond"), null);
+    assert.equal(parseSlashCommand("/respond ab12cd34"), null, "shortId without text");
+});
+test("v0.10.x: parseSlashCommand /respond preserves dashed shortId", () => {
+    const got = parseSlashCommand("/respond ab12-cd34-ef56 yes do it");
+    assert.deepEqual(got, { cmd: "respond", shortId: "ab12-cd34-ef56", text: "yes do it" });
+});
+test("v0.10.x: parseSlashCommand /respond joins multi-word text with single spaces", () => {
+    const got = parseSlashCommand("/respond xyz the   quick brown    fox");
+    assert.deepEqual(got, { cmd: "respond", shortId: "xyz", text: "the quick brown fox" });
+});
+test("v0.10.x: parseSlashCommand strips @botname suffix even with mixed case", () => {
+    assert.deepEqual(parseSlashCommand("/Now@OrqlaudeBot"), { cmd: "now" });
+    assert.deepEqual(parseSlashCommand("/budget@somebot extra args"), { cmd: "budget" });
+});
+//# sourceMappingURL=v010_helpers.test.js.map