release: promote v0.1.37

CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.1.37 - 2026-08-23
+
+MendCode v0.1.37 prevents orphaned macOS Loop services and makes Workflow completion recovery bounded and executable.
+
+### Changed
+
+- Run macOS Loop LaunchAgents as one-shot scheduler ticks instead of leaving a persistent Bun coordinator alive between wakeups.
+- Accept bounded package-manager validation commands from relative project subdirectories, including `pnpm --dir app build`.
+
+### Fixed
+
+- Self-uninstall project Loop services after their final scheduled Loop disappears, including services already waking with an empty project scope.
+- Remove macOS LaunchAgents by their loaded label so a service can safely uninstall itself while it is running.
+- Reject unsupported Workflow completion commands before task execution instead of blocking after every task has finished.
+- Time out a stalled structured completion auditor after 3 minutes, cancel its child session, and route it through the existing bounded retry or blocked state instead of auditing forever or overlapping the retry.
+- Route completion audits through the explicit read-only Explore profile instead of silently inheriting the primary Build agent.
+- Resume a Workflow whose work already finished but whose completion audit was blocked by creating a fresh audit generation without rerunning completed tasks.
+- Keep explicit `workflows start|resume|retry-* --wait` CLI runs attached until a durable stop instead of disposing their runner immediately.
+
+### Tests
+
+- Add focused regressions for macOS one-shot scheduling and self-uninstall routing, package-manager validation safety, early Workflow plan validation, and stalled completion auditors.
+- Run 96 focused public-launcher, Loop, Workflow, scheduler, persistence, and completion tests with isolated test state, plus a real isolated macOS LaunchAgent self-removal smoke.
+
 ## 0.1.36 - 2026-08-23
 
 MendCode v0.1.36 makes Loop and Workflow supervision durable, observable, and consistent with the workspace users actually inspect.

src/mendcode/packages/extensions/zed/extension.toml

@@ -1,7 +1,7 @@
 id = "mendcode"
 name = "MendCode"
 description = "The open source coding agent."
-version = "0.1.36"
+version = "0.1.37"
 schema_version = 1
 authors = ["MendCode"]
 repository = "https://github.com/MendCode/MendCode"
@@ -11,26 +11,26 @@ name = "MendCode"
 icon = "./icons/opencode.svg"
 
 [agent_servers.mendcode.targets.darwin-aarch64]
-archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.36/mendcode-darwin-arm64.zip"
+archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.37/mendcode-darwin-arm64.zip"
 cmd = "./mendcode"
 args = ["acp"]
 
 [agent_servers.mendcode.targets.darwin-x86_64]
-archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.36/mendcode-darwin-x64.zip"
+archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.37/mendcode-darwin-x64.zip"
 cmd = "./mendcode"
 args = ["acp"]
 
 [agent_servers.mendcode.targets.linux-aarch64]
-archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.36/mendcode-linux-arm64.tar.gz"
+archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.37/mendcode-linux-arm64.tar.gz"
 cmd = "./mendcode"
 args = ["acp"]
 
 [agent_servers.mendcode.targets.linux-x86_64]
-archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.36/mendcode-linux-x64.tar.gz"
+archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.37/mendcode-linux-x64.tar.gz"
 cmd = "./mendcode"
 args = ["acp"]
 
 [agent_servers.mendcode.targets.windows-x86_64]
-archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.36/mendcode-windows-x64.zip"
+archive = "https://github.com/MendCode/MendCode/releases/download/v0.1.37/mendcode-windows-x64.zip"
 cmd = "./mendcode.exe"
 args = ["acp"]

src/mendcode/packages/opencode/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "name": "mendcode",
   "type": "module",
   "license": "MIT",

src/mendcode/packages/opencode/script/dev-rearm-smoke.ts

@@ -2,7 +2,7 @@ import { createServer, type IncomingMessage, type ServerResponse } from "node:ht
 import { once } from "node:events"
 import { probeRuntime } from "./dev-rearm"
 
-const VERSION = "0.1.36"
+const VERSION = "0.1.37"
 const PROJECT = "/tmp/mendcode-dev-rearm-smoke-project"
 
 function assert(condition: unknown, message: string): asserts condition {

src/mendcode/packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx

@@ -612,9 +612,294 @@ export function resolveWorkingStartedAt(input: {
   sessionUpdated?: number
   fallback?: number
 }) {
-  return [input.stored, input.activeAssistantCreated, input.sessionUpdated, input.fallback]
-    .filter((item): item is number => typeof item === "number" && Number.isFinite(item) && item > 0)
-    .toSorted((a, b) => a - b)[0]
+  const valid = (item: number | undefined): item is number =>
+    typeof item === "number" && Number.isFinite(item) && item > 0
+  const activeTurn = [input.stored, input.activeAssistantCreated].filter(valid).toSorted((a, b) => a - b)[0]
+  if (activeTurn) return activeTurn
+  if (valid(input.sessionUpdated)) return input.sessionUpdated
+  if (valid(input.fallback)) return input.fallback
+}
+
+export function shouldClearWorkingStartedAt(input: {
+  statusType: string
+  hasActiveWorkingAssistant?: boolean
+  permissionPending?: boolean
+  interrupted?: boolean
+  terminalAssistant?: boolean
+}) {
+  if (input.interrupted) return true
+  if (input.permissionPending) return false
+  if (input.terminalAssistant) return true
+  return input.statusType === "idle" && !input.hasActiveWorkingAssistant && !input.permissionPending
+}
+
+export function shouldKeepWorkingStatus(input: {
+  interrupted?: boolean
+  submitPreflightActive?: boolean
+  hasPendingPromptDelivery?: boolean
+  compactionActive?: boolean
+  hasActiveWorkingAssistant?: boolean
+  permissionPending?: boolean
+  terminalAssistant?: boolean
+  statusType: string
+}) {
+  if (input.interrupted) return false
+  // A stale preflight flag can survive the terminal assistant event. Do not
+  // let that local flag resurrect Generating after a completed turn.
+  if (
+    input.terminalAssistant &&
+    !input.hasPendingPromptDelivery &&
+    !input.compactionActive &&
+    !input.permissionPending &&
+    !input.hasActiveWorkingAssistant
+  )
+    return false
+  return Boolean(
+    input.submitPreflightActive ||
+      input.hasPendingPromptDelivery ||
+      input.compactionActive ||
+      !shouldClearWorkingStartedAt({
+        statusType: input.statusType,
+        hasActiveWorkingAssistant: input.hasActiveWorkingAssistant,
+        permissionPending: input.permissionPending,
+        terminalAssistant: input.terminalAssistant,
+      }),
+  )
+}
+
+export function promptWorkingIndicatorVisible(input: {
+  hasSession: boolean
+  submitPreflightActive: boolean
+  configuredVisible: boolean
+  working: boolean
+}) {
+  return (input.hasSession || input.submitPreflightActive) && input.configuredVisible && input.working
+}
+
+export function shouldEnableSessionInterrupt(input: {
+  statusType: string
+  hasActiveWorkingAssistant?: boolean
+  hasPendingPromptDelivery?: boolean
+  autocompleteVisible?: boolean
+  promptFocused?: boolean
+  compactionActive?: boolean
+  interruptRequested?: boolean
+}) {
+  if (input.interruptRequested) return false
+  // An active turn owns Esc even when autocomplete/another prompt overlay has
+  // focus, so the first press can arm cancellation without closing the overlay.
+  if (
+    input.statusType !== "idle" ||
+    input.hasActiveWorkingAssistant ||
+    input.hasPendingPromptDelivery ||
+    input.compactionActive
+  )
+    return true
+  if (input.autocompleteVisible) return false
+  return false
+}
+
+export function hasInterruptibleSessionTurn(input: {
+  statusType: string
+  hasDraft?: boolean
+  hasActiveWorkingAssistant?: boolean
+  hasPendingPromptDelivery?: boolean
+  compactionActive?: boolean
+}) {
+  return (
+    input.statusType !== "idle" ||
+    Boolean(input.hasActiveWorkingAssistant || input.hasPendingPromptDelivery || input.compactionActive)
+  )
+}
+
+export function sessionInterruptConfirmationAction(input: {
+  activeTargetMessageID?: string
+  armedTargetMessageID?: string
+}): "ignore" | "arm" | "interrupt" {
+  if (!input.activeTargetMessageID) return "ignore"
+  return input.armedTargetMessageID === input.activeTargetMessageID ? "interrupt" : "arm"
+}
+
+export function sessionInterruptHint(input: { enabled: boolean; working: boolean; armed: boolean }) {
+  if (!input.enabled || !input.working || !input.armed) return
+  return "[esc again to interrupt]"
+}
+
+export function clipboardPasteAction(content: { mime?: string; data?: string } | undefined): "image" | "text" | "none" {
+  if (!content) return "none"
+  if (content.mime?.startsWith("image/")) return "image"
+  if (content.mime === "text/plain" && content.data) return "text"
+  return "none"
+}
+
+export function shouldAcceptPromptInterruptFocus(input: {
+  inputFocused: boolean
+  currentFocusedRenderable?: unknown
+  promptInput?: unknown
+}) {
+  return input.inputFocused && input.currentFocusedRenderable === input.promptInput
+}
+
+export function shouldUseStoredPromptHistoryFallback(input: {
+  historyItems?: () => readonly PromptInfo[]
+  messageHistoryCount?: number
+}) {
+  return input.historyItems === undefined
+}
+
+function stablePromptPartForHistory(part: PromptInfo["parts"][number]) {
+  if (part.type === "text" && part.source?.text) {
+    return {
+      ...part,
+      source: {
+        ...part.source,
+        text: {
+          value: part.source.text.value,
+        },
+      },
+    }
+  }
+  if (part.type === "file" && part.source?.text) {
+    return {
+      ...part,
+      source: {
+        ...part.source,
+        text: {
+          value: part.source.text.value,
+        },
+      },
+    }
+  }
+  if (part.type === "agent" && part.source) {
+    return {
+      ...part,
+      source: {
+        value: part.source.value,
+      },
+    }
+  }
+  return part
+}
+
+export function promptHistoryMatchesCurrent(input: {
+  currentPrompt: PromptInfo
+  currentMode: "normal" | "shell"
+  historyIndex: number
+  historyPrompt?: PromptInfo
+}) {
+  if (input.historyIndex === 0) return input.currentPrompt.input.length === 0 && input.currentPrompt.parts.length === 0
+  if (!input.historyPrompt) return false
+  if (input.currentPrompt.input !== input.historyPrompt.input) return false
+  if (input.currentMode !== (input.historyPrompt.mode ?? "normal")) return false
+  return (
+    JSON.stringify(input.currentPrompt.parts.map(stablePromptPartForHistory)) ===
+    JSON.stringify(input.historyPrompt.parts.map(stablePromptPartForHistory))
+  )
+}
+
+export function shouldPreferMessagePromptHistory(input: { direction?: 1 | -1; currentPromptMatchesHistory: boolean }) {
+  if (input.direction === undefined) return false
+  return input.currentPromptMatchesHistory
+}
+
+function trailingPromptPlaceholderStart(input: { text: string; parts?: readonly PromptInfo["parts"][number][] }) {
+  const trimmedEnd = input.text.trimEnd().length
+  return input.parts
+    ?.flatMap((part) => {
+      if ((part.type === "text" || part.type === "file") && part.source?.text) return [part.source.text]
+      if (part.type === "agent" && part.source) return [part.source]
+      return []
+    })
+    .filter((source) => source.end >= trimmedEnd)
+    .map((source) => source.start)
+    .sort((a, b) => a - b)
+    .at(0)
+}
+
+export function shouldAttemptPromptHistoryNavigation(input: {
+  direction?: 1 | -1
+  cursorOffset: number
+  text: string
+  parts?: readonly PromptInfo["parts"][number][]
+}) {
+  if (input.direction === undefined) return false
+  if (input.direction === -1) return input.cursorOffset === 0
+  if (input.cursorOffset === promptCursorEndOffset(input.text)) return true
+  const placeholderStart = trailingPromptPlaceholderStart(input)
+  return placeholderStart !== undefined && input.cursorOffset >= placeholderStart
+}
+
+export function shouldSnapPromptCursorToEnd(input: {
+  direction?: 1 | -1
+  cursorOffset: number
+  text: string
+  visualRow: number
+  totalVisualRows: number
+  scrollY: number
+}) {
+  if (input.direction !== 1) return false
+  // OpenTUI reports visualRow relative to the viewport. Use the total wrapped
+  // row count instead of logical newline count so long lines do not look like
+  // the end of the prompt while ArrowDown is still scrolling through them.
+  const absoluteVisualRow = input.visualRow + input.scrollY
+  return absoluteVisualRow >= input.totalVisualRows - 1 && input.cursorOffset < promptCursorEndOffset(input.text)
+}
+
+export function shouldHandlePromptCursorArrow(input: Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super">) {
+  if (input.ctrl || input.meta || input.shift || input.super) return false
+  return input.name === "left" || input.name === "right"
+}
+
+export function promptDraftHistoryAction(input: { undo: boolean; redo: boolean; canUndo: boolean; canRedo: boolean }) {
+  if (input.undo && input.canUndo) return "undo" as const
+  if (input.redo && input.canRedo) return "redo" as const
+
+  return undefined
+}
+
+export function promptCursorEndOffset(text: string) {
+  return text.length
+}
+
+export function promptCursorOffsetAfterArrow(input: {
+  cursorOffset: number
+  text: string
+  direction: "left" | "right"
+  atomicRanges?: readonly { start: number; end: number }[]
+}) {
+  const textEnd = promptCursorEndOffset(input.text)
+  const cursorOffset = Math.max(0, Math.min(textEnd, input.cursorOffset))
+  const atomicRanges = (input.atomicRanges ?? [])
+    .filter((range) => Number.isFinite(range.start) && Number.isFinite(range.end) && range.end > range.start)
+    .map((range) => ({
+      start: Math.max(0, Math.min(textEnd, range.start)),
+      end: Math.max(0, Math.min(textEnd, range.end)),
+    }))
+    .filter((range) => range.end > range.start)
+
+  if (input.direction === "left") {
+    const atomicRange = atomicRanges.find((range) => cursorOffset > range.start && cursorOffset <= range.end)
+    if (atomicRange) return Math.max(0, atomicRange.start - 1)
+    return Math.max(0, cursorOffset - 1)
+  }
+
+  const atomicRange = atomicRanges.find((range) => cursorOffset >= range.start && cursorOffset < range.end)
+  if (atomicRange) return atomicRange.end
+  return Math.min(textEnd, cursorOffset + 1)
+}
+
+export function promptCursorOffsetFromMouse(input: { visualOffset: number; text: string }) {
+  return Math.max(0, Math.min(promptCursorEndOffset(input.text), Math.floor(input.visualOffset)))
+}
+
+function removeVisibleResolvingText(value: string) {
+  return value.replace(/(?:^|\s)(?:[^\w\s]\s*)*Resolving\s+\[\d+\/\d+\]\s*/giu, (match) =>
+    match.startsWith(" ") ? " " : "",
+  )
+}
+
+function cleanPromptInputText(value: string) {
+  return removeVisibleResolvingText(value)
 }
 
 export function shouldClearWorkingStartedAt(input: {