@glrs-dev/harness-plugin-opencode 2.1.0 → 2.3.0

package/dist/loop-session-J35NILUZ.js

@@ -0,0 +1,30 @@
+import {
+  runRalphLoop
+} from "./chunk-NIFAVPNN.js";
+import "./chunk-MJSMBY2Y.js";
+import "./chunk-GCWHRUOK.js";
+
+// src/autopilot/loop-session.ts
+import * as fs from "fs";
+import * as path from "path";
+async function runLoopSession(opts) {
+  const _runRalphLoop = opts._deps?.runRalphLoop ?? runRalphLoop;
+  const isDirectory = opts._deps?.isDirectory ? opts._deps.isDirectory(opts.planPath) : (() => {
+    try {
+      return fs.statSync(opts.planPath).isDirectory();
+    } catch {
+      return false;
+    }
+  })();
+  let prompt;
+  if (isDirectory) {
+    const mainMd = path.join(opts.planPath, "main.md");
+    prompt = `Work the plan at ${mainMd}. Find the first unchecked phase in ## Phases and complete all its items. Continue until all phases are checked and all main.md items are checked. Mark items done as they complete.`;
+  } else {
+    prompt = `Work the plan at ${opts.planPath}. Complete all items in ## Acceptance criteria. Mark items done as they complete.`;
+  }
+  return _runRalphLoop({ prompt, cwd: opts.cwd });
+}
+export {
+  runLoopSession
+};

package/dist/opencode-server-KPCDFYAX.js

@@ -0,0 +1,22 @@
+import {
+  DEFAULT_STARTUP_TIMEOUT_MS,
+  createSession,
+  execFileP,
+  getLastAssistantMessage,
+  getSessionCost,
+  selfTest,
+  sendAndWait,
+  startServer,
+  waitForIdle
+} from "./chunk-GCWHRUOK.js";
+export {
+  DEFAULT_STARTUP_TIMEOUT_MS,
+  createSession,
+  execFileP,
+  getLastAssistantMessage,
+  getSessionCost,
+  selfTest,
+  sendAndWait,
+  startServer,
+  waitForIdle
+};

package/dist/plan-parser-TMHEKT22.js

@@ -0,0 +1,6 @@
+import {
+  parsePlanState
+} from "./chunk-MJSMBY2Y.js";
+export {
+  parsePlanState
+};

package/dist/plan-session-7VS32P52.js

@@ -0,0 +1,117 @@
+import {
+  createSession,
+  sendAndWait,
+  startServer
+} from "./chunk-GCWHRUOK.js";
+
+// src/autopilot/plan-session.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEFAULT_PLAN_TIMEOUT_MS = 10 * 60 * 1e3;
+async function runPlanSession(opts) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_PLAN_TIMEOUT_MS;
+  const _startServer = opts._deps?.startServer ?? startServer;
+  const _createSession = opts._deps?.createSession ?? createSession;
+  const _sendAndWait = opts._deps?.sendAndWait ?? sendAndWait;
+  const _existsSync = opts._deps?.existsSync ?? fs.existsSync;
+  const server = await _startServer({ cwd: opts.planDir });
+  try {
+    const sessionId = await _createSession(server.client, {
+      cwd: opts.planDir,
+      agentName: "plan"
+    });
+    const multiFileDir = path.join(opts.planDir, opts.slug);
+    const multiFileMain = path.join(multiFileDir, "main.md");
+    const singleFilePlan = path.join(opts.planDir, `${opts.slug}.md`);
+    const prompt = `Read the scope at ${opts.scopePath} and produce a plan. Use slug ${opts.slug} for the plan file(s). If the scope warrants multiple phases, produce a multi-file plan at ${multiFileDir}/main.md + phase_N.md files. Otherwise produce a single-file plan at ${singleFilePlan}.`;
+    const result = await _sendAndWait(server.client, {
+      sessionId,
+      message: prompt,
+      agentName: "plan",
+      stallMs: timeoutMs,
+      autoRejectPermissions: true,
+      serverUrl: server.url
+    });
+    if (result.kind === "abort") {
+      throw new Error(
+        `Plan session aborted (timeout after ${timeoutMs}ms).`
+      );
+    }
+    if (result.kind === "stall") {
+      throw new Error(
+        `Plan session stalled for ${result.stallMs}ms with no idle signal.`
+      );
+    }
+    if (result.kind === "error") {
+      throw new Error(`Plan session error: ${result.message}`);
+    }
+    if (result.kind === "question_rejected") {
+      process.stderr.write(
+        `
+  \u26A0 @plan tried to ask a question (rejected). Checking if plan was written anyway...
+`
+      );
+    }
+    if (_existsSync(multiFileMain)) {
+      return { planPath: multiFileDir };
+    }
+    if (_existsSync(singleFilePlan)) {
+      return { planPath: singleFilePlan };
+    }
+    process.stderr.write(
+      `
+  \u26A0 @plan didn't write a plan file. Re-sending with explicit instructions...
+`
+    );
+    const retryPrompt = `You did not write a plan file. Write the plan NOW. Read the scope at ${opts.scopePath}. Write the plan to ${singleFilePlan} (single-file) or ${multiFileDir}/main.md (multi-file). Do NOT ask questions. Just write the plan.`;
+    const retryResult = await _sendAndWait(server.client, {
+      sessionId,
+      message: retryPrompt,
+      agentName: "plan",
+      stallMs: timeoutMs,
+      autoRejectPermissions: true,
+      serverUrl: server.url
+    });
+    if (retryResult.kind !== "idle" && retryResult.kind !== "question_rejected") {
+      throw new Error(`@plan retry failed: ${retryResult.kind}`);
+    }
+    if (_existsSync(multiFileMain)) {
+      return { planPath: multiFileDir };
+    }
+    if (_existsSync(singleFilePlan)) {
+      return { planPath: singleFilePlan };
+    }
+    process.stderr.write(
+      `
+  \u26A0 @plan still didn't write a plan. Constructing minimal plan from scope.
+`
+    );
+    const scopeContent = fs.existsSync(opts.scopePath) ? fs.readFileSync(opts.scopePath, "utf-8") : `# Plan
+
+Scope file not found at ${opts.scopePath}.`;
+    const minimalPlan = [
+      `# Plan (auto-generated from scope)`,
+      "",
+      "This plan was auto-generated because @plan did not produce a plan file.",
+      "Review and refine before executing.",
+      "",
+      scopeContent,
+      "",
+      "## Acceptance criteria",
+      "",
+      "- [ ] Review and refine this auto-generated plan",
+      "",
+      "## File-level changes",
+      "",
+      "- To be determined after plan review."
+    ].join("\n");
+    fs.mkdirSync(path.dirname(singleFilePlan), { recursive: true });
+    fs.writeFileSync(singleFilePlan, minimalPlan);
+    return { planPath: singleFilePlan };
+  } finally {
+    await server.shutdown();
+  }
+}
+export {
+  runPlanSession
+};

package/dist/scoper-S77SOK7X.js

@@ -0,0 +1,326 @@
+import {
+  createSession,
+  getLastAssistantMessage,
+  sendAndWait,
+  startServer
+} from "./chunk-GCWHRUOK.js";
+
+// src/autopilot/scoper.ts
+import * as fs from "fs";
+import * as path from "path";
+var ANSI_RESET = "\x1B[0m\x1B[2K\r";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createSpinner() {
+  let timer = null;
+  let frame = 0;
+  return {
+    start(label = "Thinking") {
+      if (timer) return;
+      frame = 0;
+      const isTTY = process.stderr.isTTY ?? false;
+      if (!isTTY) return;
+      timer = setInterval(() => {
+        const f = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+        process.stderr.write(`\x1B[2K\r\x1B[36m${f}\x1B[0m ${label}...`);
+        frame++;
+      }, 80);
+    },
+    stop() {
+      if (!timer) return;
+      clearInterval(timer);
+      timer = null;
+      process.stderr.write("\x1B[2K\r");
+    }
+  };
+}
+function parseQuestion(response) {
+  const match = response.match(/^([^\n]{1,199}\?)\s*$/);
+  return match ? match[1] ?? null : null;
+}
+function parseScopeSummary(response) {
+  const match = response.match(/^SCOPE_SUMMARY:\s*\n?([\s\S]+)$/);
+  return match ? match[1]?.trim() ?? null : null;
+}
+function extractScopeCompletePath(output) {
+  const lines = output.split("\n");
+  let lastMatch = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("SCOPE_COMPLETE:")) {
+      const rest = trimmed.slice("SCOPE_COMPLETE:".length).trim();
+      if (rest.length > 0) {
+        lastMatch = rest;
+      }
+    }
+  }
+  return lastMatch;
+}
+var DEFAULT_SCOPER_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_QUESTIONS = 8;
+var FORCED_FINALIZE_MESSAGE = "You have asked enough questions. Present a SCOPE_SUMMARY for user approval, then write scope.md and emit SCOPE_COMPLETE.";
+var PARSE_RETRY_REMINDER = "Your last response did not follow the strict contract. Respond with EXACTLY one of: (a) a single question (\u2264200 chars, ending with '?'), (b) a scope summary starting with 'SCOPE_SUMMARY:', or (c) the sentinel 'SCOPE_COMPLETE: <absolute-path>'. Nothing else.";
+async function runScoperSession(opts) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_SCOPER_TIMEOUT_MS;
+  const _startServer = opts._deps?.startServer ?? startServer;
+  const _createSession = opts._deps?.createSession ?? createSession;
+  const _sendAndWait = opts._deps?.sendAndWait ?? sendAndWait;
+  const _getLastAssistantMessage = opts._deps?.getLastAssistantMessage ?? getLastAssistantMessage;
+  const _existsSync = opts._deps?.existsSync ?? fs.existsSync;
+  const _promptUser = opts._deps?.promptUser ?? (async (question) => {
+    const { input } = await import("@inquirer/prompts");
+    return input({ message: question });
+  });
+  const server = await _startServer({ cwd: opts.planDir });
+  const spinner = createSpinner();
+  try {
+    const sessionId = await _createSession(server.client, {
+      cwd: opts.planDir,
+      agentName: "scoper"
+    });
+    const initialPrompt = [
+      "You are running in an inquirer-driven wizard. Follow the strict response contract:",
+      "- Every response must be EXACTLY one of:",
+      "  (a) A single question (\u2264200 chars, ending with '?')",
+      "  (b) A scope summary starting with 'SCOPE_SUMMARY:' for user approval",
+      "  (c) The sentinel 'SCOPE_COMPLETE: <absolute-path>'",
+      "- Do NOT call the question tool. Emit questions as plain assistant text.",
+      "- Start with first-principles questions (WHAT and WHY), not implementation details.",
+      "",
+      `The user wants to build: ${opts.initialGoal}`,
+      "",
+      "Begin by asking your first clarifying question about the problem being solved."
+    ].join("\n");
+    spinner.start("Scoper is thinking");
+    const firstResult = await _sendAndWait(server.client, {
+      sessionId,
+      message: initialPrompt,
+      agentName: "scoper",
+      stallMs: timeoutMs,
+      autoRejectPermissions: true
+    });
+    if (firstResult.kind === "abort") {
+      throw new Error(`Scoper session aborted (timeout after ${timeoutMs}ms).`);
+    }
+    if (firstResult.kind === "stall") {
+      throw new Error(
+        `Scoper session stalled for ${firstResult.stallMs}ms with no idle signal.`
+      );
+    }
+    if (firstResult.kind === "error") {
+      throw new Error(`Scoper session error: ${firstResult.message}`);
+    }
+    let questionsAsked = 0;
+    let parseRetryPending = false;
+    while (true) {
+      const lastMessage = await _getLastAssistantMessage(
+        server.client,
+        sessionId
+      );
+      const scopePath = extractScopeCompletePath(lastMessage);
+      if (scopePath) {
+        spinner.stop();
+        if (!_existsSync(scopePath)) {
+          throw new Error(
+            `Scoper emitted SCOPE_COMPLETE but scope.md does not exist at: ${scopePath}`
+          );
+        }
+        return { scopePath };
+      }
+      if (questionsAsked >= MAX_QUESTIONS) {
+        spinner.start("Finalizing scope");
+        const finalResult = await _sendAndWait(server.client, {
+          sessionId,
+          message: FORCED_FINALIZE_MESSAGE,
+          stallMs: timeoutMs,
+          autoRejectPermissions: true
+        });
+        if (finalResult.kind !== "idle") {
+          throw new Error(
+            `Scoper session failed during forced finalize: ${finalResult.kind}`
+          );
+        }
+        const finalMessage = await _getLastAssistantMessage(
+          server.client,
+          sessionId
+        );
+        const finalScopePath = extractScopeCompletePath(finalMessage);
+        if (finalScopePath) {
+          spinner.stop();
+          if (!_existsSync(finalScopePath)) {
+            throw new Error(
+              `Scoper emitted SCOPE_COMPLETE after forced finalize but scope.md does not exist at: ${finalScopePath}`
+            );
+          }
+          return { scopePath: finalScopePath };
+        }
+        const expectedScopePath = path.join(opts.planDir, opts.slug, "scope.md");
+        if (_existsSync(expectedScopePath)) {
+          spinner.stop();
+          process.stderr.write(
+            `
+  \u26A0 Scoper didn't emit sentinel, but scope.md exists at ${expectedScopePath}. Using it.
+
+`
+          );
+          return { scopePath: expectedScopePath };
+        }
+        spinner.stop();
+        process.stderr.write(
+          `
+  \u26A0 Scoper didn't write scope.md. Constructing from conversation.
+
+`
+        );
+        const scopeDir = path.join(opts.planDir, opts.slug);
+        if (!_existsSync(scopeDir)) {
+          fs.mkdirSync(scopeDir, { recursive: true });
+        }
+        const constructedScope = [
+          `# ${opts.initialGoal}`,
+          "",
+          "## Goal",
+          "",
+          opts.initialGoal,
+          "",
+          "## Scoper conversation summary",
+          "",
+          "The scoper agent asked 8 questions and the user provided answers,",
+          "but the agent did not produce a formal scope.md. The last agent",
+          "response is included below for the plan agent to work from.",
+          "",
+          "### Last agent response",
+          "",
+          finalMessage || "(no response captured)",
+          "",
+          "## Acceptance criteria",
+          "",
+          "- To be determined by the plan agent based on the conversation above.",
+          "",
+          "## Constraints",
+          "",
+          "- To be determined by the plan agent.",
+          "",
+          "## Out of scope",
+          "",
+          "- To be determined by the plan agent.",
+          "",
+          "## Open questions for the plan agent",
+          "",
+          "- The scoper did not complete formally. Review the conversation summary above and fill in the missing sections."
+        ].join("\n");
+        const constructedPath = path.join(scopeDir, "scope.md");
+        fs.writeFileSync(constructedPath, constructedScope);
+        return { scopePath: constructedPath };
+      }
+      const summary = parseScopeSummary(lastMessage);
+      if (summary) {
+        spinner.stop();
+        parseRetryPending = false;
+        process.stderr.write(ANSI_RESET);
+        process.stderr.write(`
+\x1B[1m\u{1F4CB} Scope summary:\x1B[0m
+
+${summary}
+
+`);
+        const approval = await _promptUser("Approve this scope? (yes / or describe what to change)");
+        if (approval.toLowerCase().startsWith("yes") || approval.toLowerCase() === "y" || approval.toLowerCase() === "approve") {
+          spinner.start("Writing scope.md");
+          const writeResult = await _sendAndWait(server.client, {
+            sessionId,
+            message: "The user approved the scope. Write scope.md now and emit SCOPE_COMPLETE.",
+            stallMs: timeoutMs,
+            autoRejectPermissions: true
+          });
+          if (writeResult.kind !== "idle") {
+            throw new Error(
+              `Scoper session failed after scope approval: ${writeResult.kind}`
+            );
+          }
+          continue;
+        } else {
+          spinner.start("Scoper is revising");
+          const reviseResult = await _sendAndWait(server.client, {
+            sessionId,
+            message: approval,
+            stallMs: timeoutMs,
+            autoRejectPermissions: true
+          });
+          if (reviseResult.kind !== "idle") {
+            throw new Error(
+              `Scoper session failed during revision: ${reviseResult.kind}`
+            );
+          }
+          continue;
+        }
+      }
+      const question = parseQuestion(lastMessage);
+      if (question) {
+        parseRetryPending = false;
+        spinner.stop();
+        process.stderr.write(ANSI_RESET);
+        questionsAsked++;
+        const userAnswer = await _promptUser(question);
+        spinner.start("Scoper is thinking");
+        const nextResult = await _sendAndWait(server.client, {
+          sessionId,
+          message: userAnswer,
+          stallMs: timeoutMs,
+          autoRejectPermissions: true
+        });
+        if (nextResult.kind === "abort") {
+          throw new Error(
+            `Scoper session aborted (timeout after ${timeoutMs}ms).`
+          );
+        }
+        if (nextResult.kind === "stall") {
+          throw new Error(
+            `Scoper session stalled for ${nextResult.stallMs}ms with no idle signal.`
+          );
+        }
+        if (nextResult.kind === "error") {
+          throw new Error(`Scoper session error: ${nextResult.message}`);
+        }
+        continue;
+      }
+      if (parseRetryPending) {
+        spinner.stop();
+        throw new Error(
+          `Scoper response did not follow the strict contract after retry. Last response: ${lastMessage.slice(0, 200)}`
+        );
+      }
+      parseRetryPending = true;
+      spinner.start("Retrying");
+      const retryResult = await _sendAndWait(server.client, {
+        sessionId,
+        message: PARSE_RETRY_REMINDER,
+        stallMs: timeoutMs,
+        autoRejectPermissions: true
+      });
+      if (retryResult.kind === "abort") {
+        throw new Error(
+          `Scoper session aborted during parse retry (timeout after ${timeoutMs}ms).`
+        );
+      }
+      if (retryResult.kind === "stall") {
+        throw new Error(
+          `Scoper session stalled during parse retry for ${retryResult.stallMs}ms.`
+        );
+      }
+      if (retryResult.kind === "error") {
+        throw new Error(
+          `Scoper session error during parse retry: ${retryResult.message}`
+        );
+      }
+    }
+  } finally {
+    spinner.stop();
+    await server.shutdown();
+  }
+}
+export {
+  extractScopeCompletePath,
+  parseQuestion,
+  parseScopeSummary,
+  runScoperSession
+};

package/dist/skills/adversarial-review-rubric/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: adversarial-review-rubric
+description: Use when reviewing a diff or PR against a plan or acceptance criteria.
+---
+
+# Adversarial review rubric
+
+## MECE rubric (five dimensions)
+
+Every review evaluates five dimensions — every dimension must pass for `[PASS]` or `[PASS_SPEC]`:
+
+1. **Correctness** — Does the code do what the plan says? Are acceptance criteria met?
+2. **Completeness** — Are all plan items implemented? Are edge cases handled?
+3. **Consistency** — Does the code follow existing patterns? Are naming/types consistent?
+4. **Safety** — Are there security, data-loss, or deployment risks?
+5. **Scope** — Does the diff stay within the plan's `## File-level changes`? No unplanned additions?
+
+## Progressive strictness
+
+Strictness increases across Assess iterations within a session:
+
+- **Level 1/3 (first Assess):** Standard review. Trust-recent-green applies. Focus on correctness and scope.
+- **Level 2/3 (second Assess, after FIX-INLINE loop):** Elevated scrutiny. Re-run tests unconditionally. Check all five MECE dimensions explicitly.
+- **Level 3/3 (third Assess, after LOOP-TO-PLAN):** Maximum strictness. Treat as a fresh review. Escalate to `@code-reviewer-thorough` regardless of diff size.
+
+## Red CI blocks merge
+
+**Red CI blocks merge.** Any red output from typecheck, test, or lint is a FAIL regardless of whether the failure appears pre-existing. Pre-existing status does not exempt a failure from blocking merge. There is no deferral path.
+
+## Unevidenced pre-existing claim rejection
+
+**Unevidenced pre-existing claims are rejected.** A claim that a failure is "pre-existing" or "unrelated" is only valid with ALL THREE of:
+
+- (a) a specific commit SHA showing the failure pre-dates this branch,
+- (b) `git log` output confirming the commit,
+- (c) merge-base reproduction confirming the failure exists on the merge-base.
+
+Without all three, treat the claim as unevidenced and fail the review.
+
+## Return tokens
+
+Return tokens are agent-role contracts and stay in each agent's own prompt. For reference:
+
+- `@spec-reviewer` uses: `[PASS_SPEC]` or `[FAIL_SPEC: <summary>]`
+- `@code-reviewer` and `@code-reviewer-thorough` use: `[PASS]`, `[LOOP-TO-PLAN: <summary>]`, or `[FIX-INLINE: <summary>]`
+
+Use the tokens appropriate to your role as defined in your own prompt.

package/dist/skills/code-quality/SKILL.md

@@ -26,7 +26,7 @@ Each rule file applies all four principles through the lens of a specific pipeli
 
 3. [`rules/building.md`](rules/building.md) — For `@build`. Enforce surgical changes. Verify names before using them. Flag unplanned edits. Write failure-path tests before happy-path code.
 
-4. [`rules/review.md`](rules/review.md) — For `@qa-reviewer` and `@qa-thorough`. Verify failure-path coverage in the diff. Grep-confirm cross-boundary string literals. Reject diffs with unplanned scope.
+4. [`rules/review.md`](rules/review.md) — For `@spec-reviewer`, `@code-reviewer`, and `@code-reviewer-thorough`. Verify failure-path coverage in the diff. Grep-confirm cross-boundary string literals. Reject diffs with unplanned scope.
 
 ## When to load this skill
 

package/dist/skills/root-cause-diagnosis/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: root-cause-diagnosis
+description: Use when a test, lint, or typecheck failure appears unexpectedly — before assuming it's pre-existing or unrelated.
+---
+
+# Root-cause diagnosis protocol
+
+When any test, lint, or typecheck fails during execution, run this protocol before concluding anything about the failure's origin:
+
+1. **Reproduce on merge-base.** Run `git stash && git merge-base HEAD origin/main` (fallback `origin/master`), check out the merge-base, run the failing command, then restore: `git checkout -` and `git stash pop`. If the failure reproduces on the merge-base, it pre-dates this branch — but it still blocks merge.
+2. **git blame the failing line.** Run `git blame <file> -L <line>,<line>` to identify the commit that introduced the failure. If the commit is on this branch, you introduced it — fix it. If the commit pre-dates this branch, it is pre-existing — but it still blocks merge.
+3. **Scope check.** If fixing the pre-existing failure would require touching >~5 files outside the plan's `## File-level changes`, STOP with a reorganization proposal. Do NOT defer or log-and-continue.
+
+**Exception (TDD-RED state):** Tests written in this session under the TDD order (RED → GREEN) are EXPECTED to fail before their corresponding implementation step. The diagnosis protocol fires on UNEXPECTED failures — tests or lints that were green before your session and are now red, or tests from previous sessions that have started failing. A test you just wrote that has never been green is not an unexpected failure.
+
+## Root-cause rationalization table
+
+| Excuse | Reality |
+|---|---|
+| "This test was probably already failing before my change" | "Probably" is not evidence. Run the merge-base reproduction. |
+| "Likely pre-existing — unrelated to my diff" | "Likely" is not evidence. Run `git blame` and show the commit SHA. |
+| "This failure is in a different module, not my concern" | Red CI blocks merge regardless of which module owns the failure. |
+| "I'll log it to Open questions and move on" | There is no deferral path. Fix it or STOP with a reorganization proposal. |
+| "The test is flaky — it passes sometimes" | Flaky tests still block merge. Either fix the flakiness or STOP. |