@glrs-dev/cli 2.2.0 → 2.3.0

package/dist/vendor/harness-opencode/dist/autopilot/prompt-template.md

@@ -2,79 +2,103 @@
 description: Self-driving PRIME run. Accepts an issue-tracker reference, a free-form task description, or a question.
 ---
 
-You are running in autopilot mode. The user invoked `/autopilot` to hand off a task for lights-out execution. Work through the normal SPEAR workflow until all work described in the prompt is complete, then emit `<autopilot-done>` as the **first token** of your final message.
+You are running in autopilot mode. The user is reviewing your output **asynchronously** — not during the run, but after it. Every decision you make becomes either a commit the user can `git blame`, a bullet in the plan's `## Open questions`, or a line in the autopilot log. Nothing you do blocks — everything you do is observable.
 
-**Sentinel contract.** When ALL work described in the user's prompt is genuinely complete (plan executed, Resolve stage done, PR open), emit `<autopilot-done>` at the very start of your final message. The Ralph loop driver watches for this tag to know when to stop. Do NOT emit `<autopilot-done>` prematurely — only when you have truly finished everything the prompt asked for.
+This changes your default behavior in exactly one way, and you must internalize it: **do not ask the user anything.** Not via the `question` tool, not via chat prose, not by any means. The `question` tool will abort your session if invoked — the Ralph loop driver terminates any session that emits a `question.asked` event. You cannot recover from that; plan around it.
 
-**Single-shot TUI path.** When invoked from the TUI (not the CLI driver), there is no external loop watching for the sentinel. Run the SPEAR workflow once to completion. The sentinel is harmless in this context — emit it anyway so the output is consistent.
+## Replace questions with decisions
 
-**Kill switch.** If `.agent/autopilot-disable` exists in the worktree, the CLI driver will have already stopped before sending this prompt. No action needed from you.
+For every situation where the interactive PRIME would ask a question, take the specific action below instead. These are not suggestions — they are your defaults in autopilot mode:
 
-The user wants autopilot to process: $ARGUMENTS
+| Normal-PRIME behavior | Autopilot replacement |
+|---|---|
+| Frame confirmation on low-confidence Scope | Announce the frame as `→ Frame:` and proceed. If wrong, the user corrects after the run. |
+| Two-stage Assess fork (spec vs. code) | Always run spec-reviewer first, then code-reviewer on `[PASS_SPEC]`. Never ask which variant. |
+| Workflow-mechanics (branch / worktree / isolation) | Apply the deterministic heuristic from `prime.md` § `Workflow-mechanics decisions`. Announce in one line of chat. |
+| STOP-with-reorganization proposal | Write the proposal to the plan's `## Open questions` as a bullet, mark relevant acceptance boxes with `[ ]` and a note, emit `STOP: <reason>` and stop. The user resolves at the next run. |
+| Ambiguous input interpretation | Pick the most plausible interpretation. Record your reading in the plan's `## Goal` so the user can see what you decided. |
+| Scope-expansion check (> 2 files outside plan) | Expand silently if the expansion is mechanically obvious (test files for the new code, AGENTS.md updates in touched directories). Otherwise STOP with a bullet in `## Open questions`. |
+| Plan-reviewer rejection on a judgment call | 1st reject: fix. 2nd reject: narrow scope, move disputed items to `## Out of scope`. 3rd reject: emit `STOP: plan-reviewer disagreement unresolvable; needs human input`. Never ask the user. |
+| Merge-conflict / rebase resolution | STOP with `STOP: merge conflict in <file>; needs human review`. Do not attempt. |
 
-## 0. Workflow-mechanics: decide before anything else
+**The meta-rule: if the interactive PRIME would use `question`, write to the plan file instead.** Plans are the artifact the user reads after the run — that's where deferred decisions belong.
 
-Before classifying the argument, apply the workflow-mechanics heuristic from `prime.md` § `# Workflow-mechanics decisions`. Autopilot is lights-out: the rule fires automatically and silently (single line of chat, no `question` tool). Never ask the user whether to open a fresh worktree, switch branches, or stack on current — the heuristic decides.
+## Sentinel contract
 
-Abort paths (dirty tree on default branch; dirty tree on feature branch with unrelated work) mean STOP and report the one-sentence reason. The user resolves and re-runs.
+When all work in the user's prompt is complete (plan executed, Resolve stage done, PR open), emit `<autopilot-done>` as the **first token** of your final message. The Ralph loop watches for this to stop. Emit it only when truly finished — not when you think you're close, not when one iteration's acceptance criteria are met, not as a "checkpoint." Premature `<autopilot-done>` ends the whole run.
 
-If you auto-invoke `/fresh`, do NOT pass `--clean`. Cleanup stays user-triggered.
+If the loop is structurally stuck (dirty tree on default branch; merge conflict; un-tickable AC; missing upstream work), emit `STOP: <one-sentence reason>` instead. The loop logs it and exits.
 
-## 1. Classify the argument
+When invoked from the TUI (not the CLI driver), there is no external loop. Run SPEAR once to completion. Emit `<autopilot-done>` anyway for output consistency.
 
-Pick ONE of these paths:
+## Kill switch
 
-- **Issue-tracker reference** (single issue) — match any of:
-  - `<PROJECT>-<NUMBER>` where PROJECT is 2–10 uppercase letters (e.g. `ENG-1234`, `GEN-1114`) — Linear, Jira, YouTrack, Shortcut, etc.
-  - `#<NUMBER>` alone (e.g. `#1234`) — GitHub shorthand
-  - A URL to a recognized tracker (`github.com/.../issues/123`, `linear.app/.../issue/...`, `*.atlassian.net/browse/...`)
-- **Free-form task description** — any natural-language request that isn't a recognized issue ref
-- **Question** — starts with what/why/how/when/where/which/who, or ends with `?`
+If `.agent/autopilot-disable` exists in the worktree, the CLI driver has already stopped before sending this prompt. No action needed.
 
-## 2. Fetch issue content (only if step 1 returned an issue ref)
+## The user's request
 
-Probe in order, stop at the first that returns real content:
+$ARGUMENTS
 
-1. **Linear MCP** — if configured and the arg matches `<PROJECT>-<NUMBER>` shape OR is a `linear.app` URL: `linear_get_issue`.
-2. **GitHub MCP** — if configured OR the arg is a `github.com/.../issues/...` URL OR is `#<NUMBER>` and `gh` CLI is available.
-3. **Jira / Atlassian MCP** — if configured and the arg matches `<PROJECT>-<NUMBER>` OR is an `*.atlassian.net` URL.
+## Workflow
 
-If no probe resolves, report once: *"I see a ref that looks like a ticket (`<arg>`), but no issue-tracker MCP is configured. Treating as free-form — paste the issue body if you want me to ground in it."* Then proceed as free-form.
+### 0. Workflow-mechanics first
 
-Treat the fetched issue's title + description + acceptance criteria as the intent baseline. Map to the plan's `## Acceptance criteria` 1:1, in order. Do not invent entries.
+Before classifying the argument, apply the heuristic from `prime.md` § `Workflow-mechanics decisions`. Announce the result in one line of chat prefixed with `→ Workflow:`. No `question` tool, no notification.
 
-## 3. Run the PRIME arc
+Abort paths (dirty tree on default branch; dirty tree on feature branch with unrelated work) mean emit `STOP: <reason>` and exit.
 
-Run the normal SPEAR workflow from `prime.md`. Key adaptations for autopilot mode:
+If you auto-invoke `/fresh`, do NOT pass `--clean` — cleanup stays user-triggered.
 
-- **Scope.** Already classified; skip redundant classification. Announce the frame as `→ Frame:` and proceed — do NOT use the `question` tool to confirm. The user is walked away.
-- **Plan.** Delegate to `@plan`. For ref-originated requests, cite the issue ID in the plan's `## Goal`. The plan's `## Acceptance criteria` maps 1:1 to the ticket's Changes / Definition of Done list.
-- **Execute.** Delegate to `@build`. `@build` executes file-by-file and returns a summary; PRIME relays progress. Acceptance boxes get checked during `@build`'s execution.
-- **Assess.** Full suite pass + `@spec-reviewer` → `@code-reviewer` → iterate to `[PASS]`. No sentinel tokens during intermediate steps.
-- **Resolve.** Complete the Resolve stage: push branch, open PR via `gh pr create`, print PR URL.
-- **Multi-issue workflows.** If the prompt describes multiple issues, use `/fresh` between issues to isolate each on its own branch. Complete each issue's full SPEAR arc (including Resolve) before moving to the next.
+### 1. Classify the argument
 
-## 4. Guardrails
+Pick ONE:
 
-- **Never ask scoping questions.** The issue's acceptance list IS the authoritative scope. If you're tempted to ask whether to include X, the answer is: if the ticket didn't ask for it, don't include it. The `question` tool is forbidden in autopilot mode except for one narrow case: an architectural fork that blocks all progress AFTER codebase inspection, `@gap-analyzer` consultation, and precedent search (`git log`) have ALL failed to determine a default.
-- **Precedent defaults.** For helper-file location, naming, logging verbosity, error-wrapper style: search `git log` for a recent similar PR and mirror its structure. Cite the precedent commit in `## Constraints`.
-- **Plan-revision budget.** After `@plan-reviewer` returns `[REJECT]`: 1st REJECT → fix listed issues, resubmit. 2nd REJECT → narrow scope (move disputed items to `## Out of scope`). 3rd REJECT → escalate to `@architecture-advisor`.
-- **Resolve auto-ships.** When Assess returns `[PASS]`, complete the Resolve stage: push branch, open PR via `gh pr create`, print the PR URL, then stop. Do NOT re-invoke `/ship` — Resolve already did the work. `/ship` exists only as a manual resume path for interrupted sessions.
-- **Hard rules from Resolve still apply.** Never `--force`-push, never push to `main`/`master`, never `--no-verify`, never merge the PR yourself. Resolve only pushes the feature branch and opens the PR; the human gate is PR review and merge.
-- **Circular failure.** If the same test fails after the same fix twice, delegate to `@architecture-advisor` before a third attempt.
-- **STOP when stuck, don't churn.** If the plan is structurally wrong for this session (wrong branch, un-tickable AC, missing upstream work), emit a single line starting with `STOP:` followed by the specific reason. Do not re-attempt.
+- **Issue-tracker reference** (single issue) — `<PROJECT>-<NUMBER>` (2-10 uppercase letters, e.g. `ENG-1234`), `#<NUMBER>`, or a URL to a recognized tracker (`github.com/.../issues/N`, `linear.app/.../issue/...`, `*.atlassian.net/browse/...`).
+- **Free-form task description** — any natural-language request that isn't a recognized issue ref.
+- **Question** — starts with what/why/how/when/where/which/who, or ends with `?`. For questions, answer in a single assistant message then emit `<autopilot-done>`. Do not enter SPEAR.
 
-## 5. Completion
+### 2. Fetch issue content (issue refs only)
 
-When ALL work described in the prompt is complete (every issue resolved, every PR open), emit `<autopilot-done>` as the first token of your final message, followed by a brief summary:
+Probe in order, stop at the first with content:
+
+1. **Linear MCP** — for `<PROJECT>-<NUMBER>` or `linear.app` URL: `linear_get_issue`.
+2. **GitHub MCP** — for `#<NUMBER>` with `gh` available, or a `github.com/.../issues/...` URL.
+3. **Jira / Atlassian MCP** — for `<PROJECT>-<NUMBER>` or `*.atlassian.net` URL.
+
+If no probe resolves, emit `STOP: ticket ref "<arg>" but no MCP configured; paste the issue body or use free-form` and exit. Do not guess at issue content.
+
+Treat the fetched title + description + acceptance criteria as the intent baseline. Map the plan's `## Acceptance criteria` 1:1 to the ticket, in order.
+
+### 3. Run the SPEAR arc
+
+Normal SPEAR per `prime.md`, with these autopilot substitutions:
+
+- **Scope.** Argument already classified. Write the frame as `→ Frame:` and proceed. No confirmation.
+- **Plan.** Delegate to `@plan`. For ref-originated requests, cite the issue ID in the plan's `## Goal`.
+- **Execute.** Delegate to `@build`. Do not invoke Assess yourself during Execute — that's Phase 4's job.
+- **Assess.** Always dispatch `@spec-reviewer` first. On `[PASS_SPEC]`, dispatch `@code-reviewer` (or `@code-reviewer-thorough` if the diff meets the thorough thresholds). Iterate to `[PASS]`. Never prompt the user between rounds.
+- **Resolve.** When Assess returns `[PASS]`, push the branch and open the PR via `gh pr create`. Print the PR URL. Resolve auto-ships — do not invoke `/ship` yourself; `/ship` exists only as a manual resume path.
+
+For multi-issue prompts: use `/fresh` between issues to isolate each on its own branch. Complete each issue's full SPEAR arc (including Resolve) before starting the next.
+
+### 4. Guardrails (beyond "no questions")
+
+- **Precedent defaults.** For helper-file location, naming conventions, logging verbosity, error-wrapper style: `git log` for a recent similar PR and mirror. Cite the precedent commit in the plan's `## Constraints`.
+- **Hard rules from Resolve still apply.** Never `--force`-push. Never push to `main`/`master`. Never `--no-verify`. Never merge the PR yourself. Resolve pushes the feature branch and opens the PR; human gate is review + merge.
+- **Circular failure.** If the same test fails after the same fix twice, delegate to `@architecture-advisor` before a third attempt. Do not churn.
+- **STOP when stuck, don't churn.** Structurally stuck (wrong branch, un-tickable AC, missing upstream work) → emit `STOP: <reason>` and exit.
+
+### 5. Completion
+
+When all work is done, emit:
 
 ```
 <autopilot-done>
 
-Done. <One-sentence summary of what was built.>
+Done. <One-sentence summary.>
 PR(s): <url(s)>
 ```
 
-If Resolve failed or was interrupted, report the failure and the resume command: `/ship <plan-path>`.
+If Resolve failed or was interrupted, report the failure and suggest `/ship <plan-path>` as the resume command.
 
-If you stopped early due to a structural block, emit `STOP: <reason>` instead of `<autopilot-done>`.
+If you stopped early due to a structural block, emit `STOP: <reason>` instead — do not emit `<autopilot-done>`.

package/dist/vendor/harness-opencode/dist/chunk-GCWHRUOK.js

@@ -0,0 +1,259 @@
+// src/lib/opencode-server.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import {
+  createOpencodeServer,
+  createOpencodeClient
+} from "@opencode-ai/sdk";
+var execFileP = promisify(execFile);
+var DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
+async function ensureOpencodeOnPath() {
+  try {
+    await execFileP("opencode", ["--version"]);
+  } catch {
+    throw new Error(
+      "opencode CLI not found on PATH.\n  Install: https://opencode.ai\n  Or: bunx opencode upgrade"
+    );
+  }
+}
+async function startServer(opts) {
+  await ensureOpencodeOnPath();
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+  const port = opts.port ?? 0;
+  const server = await createOpencodeServer({
+    port,
+    timeout: timeoutMs,
+    hostname: "127.0.0.1"
+  });
+  const client = createOpencodeClient({ baseUrl: server.url });
+  let shutdownCalled = false;
+  const shutdown = async () => {
+    if (shutdownCalled) return;
+    shutdownCalled = true;
+    try {
+      await server.close();
+    } catch {
+    }
+  };
+  return { url: server.url, client, shutdown };
+}
+async function selfTest(client) {
+  try {
+    await client.session.list();
+  } catch (err) {
+    throw new Error(
+      `OpenCode server self-test failed \u2014 the server started but isn't responding to API calls.
+  Error: ${err instanceof Error ? err.message : String(err)}
+  Run \`opencode --version\` to verify your installation.`
+    );
+  }
+}
+async function createSession(client, opts) {
+  const result = await client.session.create({
+    query: { directory: opts.cwd },
+    body: {}
+  });
+  if (!result.data) {
+    throw new Error("session.create returned no data");
+  }
+  return result.data.id;
+}
+async function sendAndWait(client, opts) {
+  const stallMs = opts.stallMs ?? 60 * 60 * 1e3;
+  const idlePromise = waitForIdle(client, {
+    sessionId: opts.sessionId,
+    stallMs,
+    abortSignal: opts.abortSignal,
+    onToolCall: opts.onToolCall,
+    onTextDelta: opts.onTextDelta,
+    onCostUpdate: opts.onCostUpdate,
+    autoRejectPermissions: opts.autoRejectPermissions,
+    serverUrl: opts.serverUrl,
+    onPermissionRejected: opts.onPermissionRejected
+  });
+  await client.session.prompt({
+    path: { id: opts.sessionId },
+    body: {
+      parts: [{ type: "text", text: opts.message }],
+      ...opts.agentName ? { agent: opts.agentName } : {}
+    }
+  });
+  return idlePromise;
+}
+async function waitForIdle(client, opts) {
+  const stallMs = opts.stallMs ?? 60 * 60 * 1e3;
+  const sse = await client.event.subscribe();
+  const reportedToolCalls = /* @__PURE__ */ new Set();
+  return new Promise((resolve) => {
+    let stallTimer = null;
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      if (stallTimer) clearTimeout(stallTimer);
+      resolve(result);
+    };
+    const resetStall = () => {
+      if (stallTimer) clearTimeout(stallTimer);
+      stallTimer = setTimeout(() => settle({ kind: "stall", stallMs }), stallMs);
+    };
+    if (opts.abortSignal) {
+      if (opts.abortSignal.aborted) {
+        settle({ kind: "abort" });
+        return;
+      }
+      opts.abortSignal.addEventListener("abort", () => settle({ kind: "abort" }), { once: true });
+    }
+    resetStall();
+    (async () => {
+      try {
+        for await (const event of sse.stream) {
+          if (settled) break;
+          const ev = event;
+          const props = ev.properties ?? {};
+          const type = ev.type ?? "";
+          if (opts.onCostUpdate && type === "message.updated") {
+            const info = props["info"];
+            if (info && info.role === "assistant" && typeof info.cost === "number") {
+              resetStall();
+              try {
+                opts.onCostUpdate(
+                  info.cost,
+                  {
+                    input: info.tokens?.input ?? 0,
+                    output: info.tokens?.output ?? 0
+                  }
+                );
+              } catch {
+              }
+            }
+          }
+          if (opts.onTextDelta && (type === "message.part.delta" || type === "message.part.updated")) {
+            const delta = props["delta"];
+            if (typeof delta === "string" && delta.length > 0) {
+              resetStall();
+              try {
+                opts.onTextDelta(delta.length);
+              } catch {
+              }
+            }
+          }
+          if (opts.onToolCall && type === "message.part.updated") {
+            const part = props["part"];
+            if (part && part.type === "tool" && part.sessionID === opts.sessionId && part.state?.status === "completed" && part.callID && !reportedToolCalls.has(part.callID)) {
+              reportedToolCalls.add(part.callID);
+              resetStall();
+              try {
+                opts.onToolCall(part.tool ?? "unknown");
+              } catch {
+              }
+              continue;
+            }
+          }
+          const eventSessionId = props["sessionID"];
+          if (opts.autoRejectPermissions && (type === "permission.updated" || type === "question.asked")) {
+            const permissionId = props["id"];
+            const permissionType = type === "question.asked" ? "question" : props["type"] ?? "unknown";
+            const permissionTitle = props["title"] ?? "";
+            if (opts.onPermissionRejected) {
+              try {
+                opts.onPermissionRejected({
+                  id: permissionId ?? "unknown",
+                  type: permissionType,
+                  title: permissionTitle
+                });
+              } catch {
+              }
+            }
+            if (type === "permission.updated" && permissionId) {
+              (async () => {
+                try {
+                  await client.postSessionIdPermissionsPermissionId({
+                    path: { id: opts.sessionId, permissionID: permissionId },
+                    body: { response: "reject" }
+                  });
+                } catch {
+                }
+              })();
+              continue;
+            }
+            if (type === "question.asked") {
+              if (opts.serverUrl && permissionId) {
+                (async () => {
+                  try {
+                    await fetch(`${opts.serverUrl}/question/${permissionId}/reject`, {
+                      method: "POST"
+                    });
+                  } catch {
+                  }
+                })();
+              }
+              settle({
+                kind: "question_rejected",
+                title: permissionTitle
+              });
+              break;
+            }
+          }
+          if (eventSessionId !== opts.sessionId) continue;
+          resetStall();
+          if (type === "session.idle") {
+            settle({ kind: "idle" });
+            break;
+          }
+          if (type === "session.error") {
+            const msg = props["message"] ?? "session error";
+            settle({ kind: "error", message: msg });
+            break;
+          }
+        }
+      } catch (err) {
+        if (!settled) {
+          settle({ kind: "error", message: err instanceof Error ? err.message : String(err) });
+        }
+      }
+    })();
+  });
+}
+async function getSessionCost(client, sessionId) {
+  try {
+    const result = await client.session.messages({ path: { id: sessionId } });
+    if (!result.data) return 0;
+    const messages = result.data;
+    let total = 0;
+    for (const m of messages) {
+      if (m.info.role === "assistant" && typeof m.info.cost === "number") {
+        total += m.info.cost;
+      }
+    }
+    return total;
+  } catch {
+    return 0;
+  }
+}
+async function getLastAssistantMessage(client, sessionId) {
+  try {
+    const result = await client.session.messages({ path: { id: sessionId } });
+    if (!result.data) return "";
+    const messages = result.data;
+    const assistantMessages = messages.filter((m) => m.info.role === "assistant");
+    if (assistantMessages.length === 0) return "";
+    const last = assistantMessages[assistantMessages.length - 1];
+    if (!last) return "";
+    return last.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+  } catch {
+    return "";
+  }
+}
+
+export {
+  execFileP,
+  DEFAULT_STARTUP_TIMEOUT_MS,
+  startServer,
+  selfTest,
+  createSession,
+  sendAndWait,
+  waitForIdle,
+  getSessionCost,
+  getLastAssistantMessage
+};

package/dist/vendor/harness-opencode/dist/chunk-MJSMBY2Y.js

@@ -0,0 +1,87 @@
+// src/autopilot/plan-parser.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEGRADED = {
+  type: "single",
+  totalItems: 0,
+  checkedItems: 0,
+  phaseCount: 0,
+  phasesCompleted: 0,
+  phases: []
+};
+function countCheckboxes(content) {
+  let total = 0;
+  let checked = 0;
+  const checkboxRe = /^[ \t]*-\s+\[([ xX])\]/gm;
+  let match;
+  while ((match = checkboxRe.exec(content)) !== null) {
+    total++;
+    if (match[1] !== " ") {
+      checked++;
+    }
+  }
+  return { total, checked };
+}
+function parseSingleFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  return countCheckboxes(content);
+}
+function detectPhaseFiles(dir) {
+  const entries = fs.readdirSync(dir);
+  return entries.filter((f) => /^phase_\d+\.md$/.test(f)).sort((a, b) => {
+    const na = parseInt(a.replace(/[^0-9]/g, ""), 10);
+    const nb = parseInt(b.replace(/[^0-9]/g, ""), 10);
+    return na - nb;
+  });
+}
+function parseMultiFile(dir) {
+  const mainPath = path.join(dir, "main.md");
+  const mainContent = fs.readFileSync(mainPath, "utf8");
+  const mainCounts = countCheckboxes(mainContent);
+  const phaseFiles = detectPhaseFiles(dir);
+  const phases = [];
+  let phasesCompleted = 0;
+  for (const phaseFile of phaseFiles) {
+    const phasePath = path.join(dir, phaseFile);
+    const { total, checked } = parseSingleFile(phasePath);
+    phases.push({ file: phaseFile, totalItems: total, checkedItems: checked });
+    if (total > 0 && checked === total) {
+      phasesCompleted++;
+    }
+  }
+  return {
+    type: "multi",
+    totalItems: mainCounts.total,
+    checkedItems: mainCounts.checked,
+    phaseCount: phaseFiles.length,
+    phasesCompleted,
+    phases
+  };
+}
+function parsePlanState(planPath) {
+  try {
+    const stat = fs.statSync(planPath);
+    if (stat.isDirectory()) {
+      const mainPath = path.join(planPath, "main.md");
+      if (fs.existsSync(mainPath)) {
+        return parseMultiFile(planPath);
+      }
+      return { ...DEGRADED, type: "multi" };
+    }
+    const { total, checked } = parseSingleFile(planPath);
+    return {
+      type: "single",
+      totalItems: total,
+      checkedItems: checked,
+      phaseCount: 0,
+      phasesCompleted: 0,
+      phases: []
+    };
+  } catch {
+    return { ...DEGRADED };
+  }
+}
+
+export {
+  parsePlanState
+};