opencode-extended-sidebar 0.2.90

package/src/pware.oc.omo/constants/pware.oc.omo.constants.backgroundTask.ts

@@ -0,0 +1,18 @@
+/**
+ * pware.oc.omo.constants.backgroundtask
+ *
+ * `.omo/run-continuation/<sessionID>.json` → `sources["background-task"].state`
+ * values.
+ */
+
+/** Background-task state: a background task is actively running. */
+export const BACKGROUND_TASK_ACTIVE = "active"
+
+/** Background-task state: no background task is running. */
+export const BACKGROUND_TASK_IDLE = "idle"
+
+/** The `sources["background-task"].state` values a run-continuation marker can hold. */
+export const BACKGROUND_TASK_STATES = [BACKGROUND_TASK_ACTIVE, BACKGROUND_TASK_IDLE] as const
+
+/** A single run-continuation background-task state value. */
+export type BackgroundTaskState = (typeof BACKGROUND_TASK_STATES)[number]

package/src/pware.oc.omo/constants/pware.oc.omo.constants.boulderStatus.ts

@@ -0,0 +1,49 @@
+/**
+ * pware.oc.omo.constants.boulderstatus
+ *
+ * OMO boulder.json work/task status values. The plugin normalizes them via
+ * core `normalizeStatus`, but the raw boulder strings belong here.
+ */
+
+/** Boulder status: work in progress. */
+export const BOULDER_STATUS_IN_PROGRESS = "in_progress"
+
+/** Boulder status: actively running. */
+export const BOULDER_STATUS_RUNNING = "running"
+
+/** Boulder status: live — the status boulder writes when a work starts. */
+export const BOULDER_STATUS_ACTIVE = "active"
+
+/** Boulder status: queued / waiting for a slot. */
+export const BOULDER_STATUS_PENDING = "pending"
+
+/** Boulder status: completed. */
+export const BOULDER_STATUS_COMPLETED = "completed"
+
+/** Boulder status: errored. */
+export const BOULDER_STATUS_ERROR = "error"
+
+/** Boulder status: paused. */
+export const BOULDER_STATUS_PAUSED = "paused"
+
+/** Boulder status: abandoned. */
+export const BOULDER_STATUS_ABANDONED = "abandoned"
+
+/** Boulder status: cancelled. */
+export const BOULDER_STATUS_CANCELLED = "cancelled"
+
+/** Raw boulder.json work/task status values. */
+export const BOULDER_STATUSES = [
+  BOULDER_STATUS_IN_PROGRESS,
+  BOULDER_STATUS_RUNNING,
+  BOULDER_STATUS_ACTIVE,
+  BOULDER_STATUS_PENDING,
+  BOULDER_STATUS_COMPLETED,
+  BOULDER_STATUS_ERROR,
+  BOULDER_STATUS_PAUSED,
+  BOULDER_STATUS_ABANDONED,
+  BOULDER_STATUS_CANCELLED,
+] as const
+
+/** A raw boulder.json work/task status value. */
+export type BoulderStatus = (typeof BOULDER_STATUSES)[number]

package/src/pware.oc.omo/constants/pware.oc.omo.constants.docKind.ts

@@ -0,0 +1,29 @@
+/**
+ * pware.oc.omo.constants.dockind
+ *
+ * OMO document kinds: the plan, drafts, notepads and evidence under `.omo/`.
+ * Indexed in `pware.oc.omo/resolver/pware.oc.omo.resolver.doc.ts`.
+ */
+
+/** Doc kind: the active plan. */
+export const DOC_KIND_PLAN = "plan"
+
+/** Doc kind: a draft plan still being written. */
+export const DOC_KIND_DRAFT = "draft"
+
+/** Doc kind: a notepad. */
+export const DOC_KIND_NOTEPAD = "notepad"
+
+/** Doc kind: evidence (proof) files. */
+export const DOC_KIND_PROOF = "proof"
+
+/** Every OMO document kind. */
+export const DOC_KINDS = [
+  DOC_KIND_PLAN,
+  DOC_KIND_DRAFT,
+  DOC_KIND_NOTEPAD,
+  DOC_KIND_PROOF,
+] as const
+
+/** An OMO document kind. */
+export type DocKind = (typeof DOC_KINDS)[number]

package/src/pware.oc.omo/constants/pware.oc.omo.constants.eventName.ts

@@ -0,0 +1,11 @@
+export const EV_OMO_BOULDER_CHANGED = "pware.omo.boulder.changed"
+export const EV_OMO_DOCS_CHANGED = "pware.omo.docs.changed"
+export const EV_OMO_CONFIG_CHANGED = "pware.omo.config.changed"
+
+export const OMO_EVENT_NAMES = [
+  EV_OMO_BOULDER_CHANGED,
+  EV_OMO_DOCS_CHANGED,
+  EV_OMO_CONFIG_CHANGED,
+] as const
+
+export type OmoEventName = (typeof OMO_EVENT_NAMES)[number]

package/src/pware.oc.omo/constants/pware.oc.omo.constants.planStatus.ts

@@ -0,0 +1,60 @@
+/**
+ * pware.oc.omo.constants.planstatus
+ *
+ * OMO plan/draft markdown frontmatter `status:` values that mean "waiting for
+ * user sign-off" (the PENDING_STATUS set currently private in the approval
+ * resolver), plus the terminal states of the plan lifecycle
+ * `drafting → awaiting-approval → approved → done`.
+ */
+
+/** Plan status: awaiting the user's approval. */
+export const PLAN_STATUS_AWAITING_APPROVAL = "awaiting-approval"
+
+/** Plan status: pending approval (hyphenated spelling). */
+export const PLAN_STATUS_PENDING_APPROVAL = "pending-approval"
+
+/** Plan status: pending approval (underscore spelling). */
+export const PLAN_STATUS_PENDING_APPROVAL_UNDERSCORE = "pending_approval"
+
+/** Plan status: pending (bare spelling). */
+export const PLAN_STATUS_PENDING = "pending"
+
+/** Plan status: draft still being written — not yet awaiting approval. */
+export const PLAN_STATUS_DRAFTING = "drafting"
+
+/** Plan status: the user approved the plan. */
+export const PLAN_STATUS_APPROVED = "approved"
+
+/** Plan status: the plan finished execution. */
+export const PLAN_STATUS_DONE = "done"
+
+/** Plan `status:` values that mean the plan is waiting for user sign-off. */
+export const PLAN_PENDING_STATUSES = [
+  PLAN_STATUS_AWAITING_APPROVAL,
+  PLAN_STATUS_PENDING_APPROVAL,
+  PLAN_STATUS_PENDING_APPROVAL_UNDERSCORE,
+  PLAN_STATUS_PENDING,
+] as const
+
+/** A plan `status:` value that counts as pending user approval. */
+export type PlanPendingStatus = (typeof PLAN_PENDING_STATUSES)[number]
+
+/** Work state: a boulder work for this plan finished. */
+export const WORK_STATE_COMPLETED = "completed"
+
+/** Work state: a boulder work exists but did not finish. */
+export const WORK_STATE_NOT_COMPLETED = "not-completed"
+
+/** Work state: no boulder work for this plan (or no boulder.json). */
+export const WORK_STATE_ABSENT = "absent"
+
+/**
+ * How the plan's boulder work relates to "finished", for the My-work
+ * reconciliation. `completed` = a boulder work for this plan finished;
+ * `not-completed` = a work exists but did not finish (running / error / paused /
+ * abandoned); `absent` = no boulder work for this plan (or no boulder.json).
+ */
+export type WorkState =
+  | typeof WORK_STATE_COMPLETED
+  | typeof WORK_STATE_NOT_COMPLETED
+  | typeof WORK_STATE_ABSENT

package/src/pware.oc.omo/constants/pware.oc.omo.constants.reviewStatus.ts

@@ -0,0 +1,49 @@
+/**
+ * pware.oc.omo.constants.reviewstatus
+ *
+ * OMO `ulw-plan` review-lifecycle status values — the state machine that runs
+ * a plan through the review lanes (momus / independent). Transitions:
+ * `pending -> launching -> in_flight -> approved | changes_requested |
+ * inconclusive`; `round_status` is `active` while a round is live.
+ */
+
+/** Review status: lane created, waiting to be launched. */
+export const REVIEW_STATUS_PENDING = "pending"
+
+/** Review status: reviewer process spawned, no receipt yet. */
+export const REVIEW_STATUS_LAUNCHING = "launching"
+
+/** Review status: reviewer process has a receipt and is working. */
+export const REVIEW_STATUS_IN_FLIGHT = "in_flight"
+
+/** Review status: reviewer approved the plan. */
+export const REVIEW_STATUS_APPROVED = "approved"
+
+/** Review status: reviewer requested changes. */
+export const REVIEW_STATUS_CHANGES_REQUESTED = "changes_requested"
+
+/** Review status: reviewer could not reach a verdict. */
+export const REVIEW_STATUS_INCONCLUSIVE = "inconclusive"
+
+/** Review status: a review round is live. */
+export const ROUND_STATUS_ACTIVE = "active"
+
+/** Every `ulw-plan` review-lifecycle status value. */
+export const REVIEW_STATUSES = [
+  REVIEW_STATUS_PENDING,
+  REVIEW_STATUS_LAUNCHING,
+  REVIEW_STATUS_IN_FLIGHT,
+  REVIEW_STATUS_APPROVED,
+  REVIEW_STATUS_CHANGES_REQUESTED,
+  REVIEW_STATUS_INCONCLUSIVE,
+] as const
+
+/** A single `ulw-plan` review-lifecycle status value. */
+export type ReviewStatus = (typeof REVIEW_STATUSES)[number]
+
+/** Terminal review statuses — a lane ends here, never resumes. */
+export const TERMINAL_REVIEW_STATUSES = [
+  REVIEW_STATUS_APPROVED,
+  REVIEW_STATUS_CHANGES_REQUESTED,
+  REVIEW_STATUS_INCONCLUSIVE,
+] as const

package/src/pware.oc.omo/constants/pware.oc.omo.constants.startWork.ts

@@ -0,0 +1,25 @@
+/**
+ * pware.oc.omo.constants.startwork
+ *
+ * Delivery modes for the OMO `start work` command. Built into the exact
+ * command text in `pware.oc.runtime/pware.oc.runtime.mywork.ts`.
+ */
+
+/** Start-work mode: plain `start work <plan>`. */
+export const START_WORK_PLAIN = "plain"
+
+/** Start-work mode: `start work <plan> --make-pr`. */
+export const START_WORK_MAKE_PR = "make-pr"
+
+/** Start-work mode: `start work <plan> --ship`. */
+export const START_WORK_SHIP = "ship"
+
+/** Every start-work delivery mode. */
+export const START_WORK_MODES = [
+  START_WORK_PLAIN,
+  START_WORK_MAKE_PR,
+  START_WORK_SHIP,
+] as const
+
+/** A start-work delivery mode. */
+export type StartWorkMode = (typeof START_WORK_MODES)[number]

package/src/pware.oc.omo/constants/pware.oc.omo.constants.verdict.ts

@@ -0,0 +1,38 @@
+/**
+ * pware.oc.omo.constants.verdict
+ *
+ * OMO review lane verdicts — the outcome a reviewer lane reports at the end of
+ * a `ulw-plan` review round (`review-work` / `visual-qa` lane protocol: one
+ * verdict per lane, one-shot; a re-review after fixes is a fresh round).
+ */
+
+/** Verdict: the review passed. */
+export const VERDICT_PASS = "pass"
+
+/** Verdict: the review found blocking problems. */
+export const VERDICT_FAIL = "fail"
+
+/** Verdict: the reviewer could not reach a conclusion. */
+export const VERDICT_INCONCLUSIVE = "inconclusive"
+
+/** Verdict: approved with or without notes. */
+export const VERDICT_APPROVED = "approved"
+
+/** Verdict: blocked, needs changes before a re-review. */
+export const VERDICT_BLOCKED = "blocked"
+
+/** Verdict: reviewer working on a long pass (progress signal). */
+export const VERDICT_WORKING = "working"
+
+/** Every review lane verdict value. */
+export const VERDICTS = [
+  VERDICT_PASS,
+  VERDICT_FAIL,
+  VERDICT_INCONCLUSIVE,
+  VERDICT_APPROVED,
+  VERDICT_BLOCKED,
+  VERDICT_WORKING,
+] as const
+
+/** A single review lane verdict value. */
+export type Verdict = (typeof VERDICTS)[number]

package/src/pware.oc.omo/index.ts

@@ -0,0 +1,7 @@
+/**
+ * pware.oc.omo
+ *
+ * oh-my-openagent domain: boulder, plans, approvals, docs index and config.
+ * Imports core only.
+ */
+export * from "./resolver/index.js"

package/src/pware.oc.omo/resolver/index.ts

@@ -0,0 +1,19 @@
+/**
+ * pware.oc.core.omo.resolver
+ *
+ * Aggregate of the omo resolvers: boulder/works/tasks/delegates, plan parsing,
+ * the approval queue, the docs index and the omo config. Re-exports the entity
+ * resolvers so consumers import from one module.
+ */
+export * from "./pware.oc.omo.resolver.boulder.js"
+export * from "./pware.oc.omo.resolver.plan.js"
+export * from "./pware.oc.omo.resolver.planFile.js"
+export * from "./pware.oc.omo.resolver.draftFile.js"
+export * from "./pware.oc.omo.resolver.notepadsFile.js"
+export * from "./pware.oc.omo.resolver.proofFile.js"
+export * from "./pware.oc.omo.resolver.rulesFile.js"
+export * from "./pware.oc.omo.resolver.runContinuationFile.js"
+export * from "./pware.oc.omo.resolver.approval.js"
+export * from "./pware.oc.omo.resolver.approvalState.js"
+export * from "./pware.oc.omo.resolver.doc.js"
+export * from "./pware.oc.omo.resolver.config.js"

package/src/pware.oc.omo/resolver/pware.oc.omo.resolver.approval.ts

@@ -0,0 +1,179 @@
+/**
+ * pware.oc.core.omo.resolver.approval
+ *
+ * OMO plan approval queue — drafts/plans under `.omo/` (or legacy `.sisyphus/`)
+ * whose `status` says they are waiting for the user's sign-off. File discovery
+ * and stat are shared with the docs index: both this module and `doc.ts` read
+ * one per-root omo scan cache, so `.omo/` is walked once per TTL no matter how
+ * many consumers ask. Classification then reads each plan/draft file's
+ * frontmatter; the result is memoized against the same scan record and is
+ * recomputed only when that record turns over. A missing `.omo/` is an empty
+ * list, not an error.
+ */
+import fs from "node:fs"
+import path from "node:path"
+import { profile } from "../../pware.oc.core/pware.oc.core.debug.js"
+import { canonicalizePath } from "../../pware.oc.core/pware.oc.core.paths.js"
+import {
+  MY_WORK_GROUP_DRAFTING,
+  MY_WORK_GROUP_FINISHED,
+  MY_WORK_GROUP_READY_REVIEW,
+  MY_WORK_GROUP_READY_START,
+} from "../../pware.oc.core/constants/pware.oc.core.constants.myWork.js"
+import { resolveApprovalGroup } from "./pware.oc.omo.resolver.approvalGroup.js"
+import { planWorkStateByPlanName } from "./pware.oc.omo.resolver.boulder.js"
+import {
+  approvalName,
+  parsePlanPendingAction,
+  parsePlanStatus,
+  parseReviewBlock,
+  type ApprovalItem,
+} from "./pware.oc.omo.resolver.plan.js"
+import { DOC_KIND_DRAFT, DOC_KIND_PLAN } from "../constants/pware.oc.omo.constants.docKind.js"
+import {
+  omoKindRows,
+  omoScanRecord,
+  resetDocsCache,
+  type OmoDocScan,
+} from "./pware.oc.omo.resolver.doc.js"
+import type { DocView } from "./pware.oc.omo.resolver.doc.js"
+
+const MAX_ITEMS = 40
+
+/** The "My work" approval buckets, keyed by group, in scan order. */
+export type ScanResult = {
+  drafting: ApprovalItem[]
+  readyReview: ApprovalItem[]
+  readyStart: ApprovalItem[]
+  finished: ApprovalItem[]
+  /** Draft documents no action group covers — approved/done, unknown or no status. */
+  draftDocs: ApprovalItem[]
+  /** Plan documents no action group covers — unknown or no status. */
+  plans: ApprovalItem[]
+}
+
+function emptyScan(): ScanResult {
+  return {
+    drafting: [],
+    readyReview: [],
+    readyStart: [],
+    finished: [],
+    draftDocs: [],
+    plans: [],
+  }
+}
+
+function sortApprovals(items: ApprovalItem[]): ApprovalItem[] {
+  items.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0) || a.name.localeCompare(b.name))
+  return items.slice(0, MAX_ITEMS)
+}
+
+function isMarkdown(rel: string): boolean {
+  return rel.toLowerCase().endsWith(".md")
+}
+
+/** Drafts/plans split into the four "My work" buckets by status + file type. */
+function classify(
+  root: string,
+  draftRows: readonly DocView[],
+  planRows: readonly DocView[],
+): ScanResult {
+  const drafting: ApprovalItem[] = []
+  const readyReview: ApprovalItem[] = []
+  const readyStart: ApprovalItem[] = []
+  const finished: ApprovalItem[] = []
+  const draftDocs: ApprovalItem[] = []
+  const plans: ApprovalItem[] = []
+  const seen = new Set<string>()
+  const workStates = planWorkStateByPlanName(root)
+  const visit = (rows: readonly DocView[], isDraft: boolean) => {
+    for (const row of rows) {
+      const rel = row.rel
+      if (!isMarkdown(rel) || seen.has(rel)) continue
+      let text = ""
+      try {
+        text = fs.readFileSync(path.join(root, rel), "utf8")
+      } catch {
+        continue
+      }
+      const status = parsePlanStatus(text)
+      const name = approvalName(rel)
+      const workState = workStates.get(name) ?? "absent"
+      // A plan with no parseable status still reconciles against boulder: one
+      // whose boulder work completed lands in Finished (resolveApprovalGroup →
+      // planWorkDone returns true for a completed work state regardless of
+      // status). A no-status plan with no completed work falls through to the
+      // Plans archive below; a no-status draft is a working document — Draft docs.
+      const group = resolveApprovalGroup(status, isDraft, workState, false)
+      const item: ApprovalItem = {
+        rel,
+        name,
+        status,
+        pendingAction: parsePlanPendingAction(text),
+        updatedAt: row.updatedAt,
+        review: parseReviewBlock(text),
+        workState,
+      }
+      seen.add(rel)
+      if (!group) {
+        // A document no action group covers (superseded approved/done, unknown
+        // or no status) is browsable, not a queue item: drafts → Draft docs,
+        // plans → Plans.
+        if (isDraft) draftDocs.push(item)
+        else plans.push(item)
+        continue
+      }
+      switch (group) {
+        case MY_WORK_GROUP_DRAFTING:
+          drafting.push(item)
+          break
+        case MY_WORK_GROUP_READY_REVIEW:
+          readyReview.push(item)
+          break
+        case MY_WORK_GROUP_READY_START:
+          readyStart.push(item)
+          break
+        case MY_WORK_GROUP_FINISHED:
+          finished.push(item)
+          break
+      }
+    }
+  }
+  visit(draftRows, true)
+  visit(planRows, false)
+  return {
+    drafting: sortApprovals(drafting),
+    readyReview: sortApprovals(readyReview),
+    readyStart: sortApprovals(readyStart),
+    finished: sortApprovals(finished),
+    draftDocs: sortApprovals(draftDocs),
+    plans: sortApprovals(plans),
+  }
+}
+
+/** Approval buckets memoized against the shared per-root omo scan record. */
+const approvalMemo = new WeakMap<OmoDocScan, ScanResult>()
+
+/** Drop the shared omo scan cache — approvals and docs both re-read next call. */
+export function resetApprovalsCache(): void {
+  resetDocsCache()
+}
+
+/** Drafts/plans split into the four "My work" buckets by status + file type. */
+export function listApprovals(projectRoot: string | null | undefined): ScanResult {
+  if (!projectRoot) return emptyScan()
+  const root = canonicalizePath(projectRoot)
+  const scan = omoScanRecord(root)
+  if (!scan) return emptyScan()
+  const memoized = approvalMemo.get(scan)
+  if (memoized) return memoized
+  const result = profile("omo.approvals", () =>
+    classify(
+      root,
+      omoKindRows(DOC_KIND_DRAFT, root),
+      omoKindRows(DOC_KIND_PLAN, root),
+    ),
+  )
+  approvalMemo.set(scan, result)
+  return result
+}

package/src/pware.oc.omo/resolver/pware.oc.omo.resolver.approvalGroup.ts

@@ -0,0 +1,116 @@
+/**
+ * pware.oc.omo.resolver.approvalGroup
+ *
+ * Which "My work" approval group a plan belongs to, from its OMO plan status
+ * alone, plus whether a plan path is still a draft. Lives in omo (not core)
+ * because it consumes the OMO plan-status constants; core may not import them.
+ */
+import {
+  MY_WORK_GROUP_DRAFTING,
+  MY_WORK_GROUP_FINISHED,
+  MY_WORK_GROUP_READY_REVIEW,
+  MY_WORK_GROUP_READY_START,
+  type ApprovalGroupKind,
+} from "../../pware.oc.core/constants/pware.oc.core.constants.myWork.js"
+import {
+  PLAN_PENDING_STATUSES,
+  PLAN_STATUS_APPROVED,
+  PLAN_STATUS_DONE,
+  PLAN_STATUS_DRAFTING,
+  WORK_STATE_ABSENT,
+  WORK_STATE_COMPLETED,
+  type WorkState,
+} from "../../pware.oc.omo/constants/pware.oc.omo.constants.planStatus.js"
+
+/** The pending sign-off set widened so `.includes()` accepts any status string. */
+const PENDING_STATUSES: readonly string[] = PLAN_PENDING_STATUSES
+
+/**
+ * Which approval group a plan belongs to, from its OMO status alone:
+ * `drafting` while still a draft, `ready-to-review` for a pending status,
+ * `ready-to-start` for an approved plan, `finished` for a done plan. Null when
+ * the item is superseded — an approved or done draft, or an unknown status —
+ * and must not be shown.
+ */
+export function approvalGroup(
+  status: string | null,
+  isDraft: boolean,
+): ApprovalGroupKind | null {
+  const s = (status ?? "").toLowerCase()
+  if (s === PLAN_STATUS_DRAFTING) return MY_WORK_GROUP_DRAFTING
+  if (PENDING_STATUSES.includes(s)) return MY_WORK_GROUP_READY_REVIEW
+  if (s === PLAN_STATUS_APPROVED) return isDraft ? null : MY_WORK_GROUP_READY_START
+  if (s === PLAN_STATUS_DONE) return isDraft ? null : MY_WORK_GROUP_FINISHED
+  return null
+}
+
+/** True when a plan path points at a draft still being written, not a final plan. */
+export function isDraftOf(rel: string): boolean {
+  return rel.startsWith("drafts/") || rel.startsWith(".sisyphus/drafts/")
+}
+
+/**
+ * True when we have trustworthy evidence the plan's work finished: a boulder
+ * work completed (layer 1), or — with no boulder work for this plan — the
+ * writer session's todos all completed (layer 2). Layer 2 only applies to an
+ * `approved` plan; a pending/drafting plan was never cleared to start, so its
+ * completed todos are the planner's, not the work's.
+ */
+export function planWorkDone(
+  status: string | null,
+  workState: WorkState,
+  todosDone: boolean,
+): boolean {
+  const s = (status ?? "").toLowerCase()
+  if (workState === WORK_STATE_COMPLETED) return true
+  if (workState === WORK_STATE_ABSENT && todosDone && s === PLAN_STATUS_APPROVED) return true
+  return false
+}
+
+/**
+ * The effective My-work group, reconciling the (untrusted) frontmatter status
+ * against boulder + db evidence. Done work → finished regardless of the
+ * frontmatter (a draft stays superseded); otherwise it falls back to the pure
+ * `approvalGroup` mapping, so the plugin still works with no boulder and no db.
+ */
+export function resolveApprovalGroup(
+  status: string | null,
+  isDraft: boolean,
+  workState: WorkState,
+  todosDone: boolean,
+): ApprovalGroupKind | null {
+  if (planWorkDone(status, workState, todosDone)) {
+    return isDraft ? null : MY_WORK_GROUP_FINISHED
+  }
+  return approvalGroup(status, isDraft)
+}
+
+/** True when the group is the drafting bucket. */
+export function isDrafting(g: ApprovalGroupKind | null): boolean {
+  return g === MY_WORK_GROUP_DRAFTING
+}
+
+/** True when the group is waiting for the user's sign-off. */
+export function isReadyToReview(g: ApprovalGroupKind | null): boolean {
+  return g === MY_WORK_GROUP_READY_REVIEW
+}
+
+/** Alias for isReadyToReview — a plan awaiting approval. */
+export function isWaitingApproval(g: ApprovalGroupKind | null): boolean {
+  return g === MY_WORK_GROUP_READY_REVIEW
+}
+
+/** Alias for isReadyToReview — a plan pending approval. */
+export function isPendingApproval(g: ApprovalGroupKind | null): boolean {
+  return g === MY_WORK_GROUP_READY_REVIEW
+}
+
+/** True when the group is approved and ready to start. */
+export function isReadyToStart(g: ApprovalGroupKind | null): boolean {
+  return g === MY_WORK_GROUP_READY_START
+}
+
+/** True when the group is finished. */
+export function isFinished(g: ApprovalGroupKind | null): boolean {
+  return g === MY_WORK_GROUP_FINISHED
+}

package/src/pware.oc.omo/resolver/pware.oc.omo.resolver.approvalState.ts

@@ -0,0 +1,34 @@
+/**
+ * pware.oc.omo.resolver.approvalstate
+ *
+ * Reads the planner session's `.omo/run-continuation` background-task marker.
+ * Lives in the omo layer — no sibling domain may read omo files. The runtime
+ * layer's my-work enrich module composes this marker with the session activity
+ * state.
+ */
+import path from "node:path"
+import { firstOmoPath } from "./pware.oc.omo.resolver.boulder.js"
+import { readJson } from "../../pware.oc.core/pware.oc.core.paths.js"
+
+/** First existing `.omo`/`.sisyphus` run-continuation directory, or null. */
+export function firstRunContinuationDir(projectRoot: string): string | null {
+  return firstOmoPath(projectRoot, "run-continuation")
+}
+
+/**
+ * The `.omo/run-continuation` background-task state for a session, or null when
+ * absent/unreadable.
+ */
+export function readRunContinuationState(
+  projectRoot: string | null | undefined,
+  sessionId: string,
+): string | null {
+  if (!projectRoot) return null
+  const dir = firstRunContinuationDir(projectRoot)
+  if (!dir) return null
+  const raw = readJson(path.join(dir, `${sessionId}.json`)) as {
+    sources?: { "background-task"?: { state?: unknown } }
+  } | null
+  const state = raw?.sources?.["background-task"]?.state
+  return typeof state === "string" ? state : null
+}