opencode-extended-sidebar 0.2.90 → 0.2.91

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

@@ -1,179 +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
-}
+/**
+ * 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

@@ -1,116 +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
-}
+/**
+ * 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

@@ -1,34 +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
-}
+/**
+ * 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
+}