@gotcos/glasses-server 6.44.2 → 6.44.4

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+## 6.44.4
+
+Stage, a finish line, and no dispatch without one.
+
+- A task row carries `stage` (planning, active or review) and `doneWhen`. Both
+  live in the tasks.md line, not a sidecar: the task id is a sha256 of the
+  normalized description, so an id-keyed store would orphan itself the first time
+  the text was edited. An unmarked row reads as planning, so nothing needed
+  migrating.
+- `PATCH /api/tasks/:id` accepts `stage` and `doneWhen`.
+- **`runTaskNow` refuses a task with no finish line**, `409 done_when_required`,
+  at the single choke point every dispatch passes through. An agent sent at a
+  task with no definition of done cannot succeed at it and cannot be judged to
+  have failed either.
+- Fixes a round-trip bug older than this release: the writer joins end-of-line
+  markers with spaces while the reader's regex allowed none between them, so a
+  row carrying both a run time and an agent marker silently lost the run time on
+  every read.
+
+## 6.44.3
+
+A task row carries enough to show and edit it.
+
+- `GET /api/tasks` rows gain `text` (the whole description), `source`, `checked`, and `owner`/`agentState`/`agentNo` when present. `title` still exists and is still capped at 44 characters, which is a G2 lens row budget: applying it to every surface is why COS Control rendered "Send James/John the call recording + recap…" in a window 1900px wide. Additive on purpose so clients through 6.9.451, which read `title`, keep working.
+- `PUT /api/domains` sets the user's domain list, so a settings pane can write it instead of the user hand-editing `~/.cos-glasses/.cos-profile.json`. It replaces the configured list wholesale and validates each name for path safety; discovered folders are never written, so removing a name from config cannot hide a folder that still holds tasks.
+- `PATCH /api/tasks/:id` accepts `text`, rewriting a task's words through a new `task-set-text` bridge subcommand. The source block, the `[run ...]` schedule, and any agent marker are rebuilt from parsed state, so editing the words never drops provenance. A task with a running agent is refused, since rewriting the line would change the task the agent was dispatched against.
+
 ## 6.44.2
 
 Task domains come from the user, not from the build.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.44.2",
+  "version": "6.44.4",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {

package/server/lib/task-dispatcher.ts

@@ -358,6 +358,16 @@ export async function runTaskNow(id: string, domain: string, injected?: TaskDisp
   if (row.agent_state === 'running') {
     throw new TaskRunError(409, 'task_running', 'A run is already in flight for this task.')
   }
+  // No finish line, no dispatch. An agent sent at a task with no definition of
+  // done cannot succeed at it and cannot be judged to have failed either, so
+  // this fails closed at the one choke point every dispatch passes through.
+  if (!row.done_when || !row.done_when.trim()) {
+    throw new TaskRunError(
+      409,
+      'done_when_required',
+      'Say what done looks like before running this task.',
+    )
+  }
   const runAt = parseRunAt(row.run_at)
   if (runAt && runAt.day > clock.day) {
     throw new TaskRunError(409, 'scheduled_future', 'Run now is not allowed on a future scheduled task.')

package/server/lib/task-store.ts

@@ -102,6 +102,12 @@ export interface BridgeTaskRow {
   agent_no: number | null
   section: string
   section_day: string | null
+  /** Workflow stage. null/absent means planning, the unmarked default.
+   *  Optional so new server code against an older bridge degrades to planning
+   *  rather than throwing during a partial deploy. */
+  stage?: 'planning' | 'active' | 'review' | null
+  /** The finish line. A dispatch is refused while this is empty. */
+  done_when?: string | null
 }
 
 export interface TaskFlags {
@@ -112,16 +118,32 @@ export interface TaskFlags {
   carriedOver: boolean
 }
 
+/** Board stage. Planning is the default and carries no marker in tasks.md. */
+export type TaskStage = 'planning' | 'active' | 'review'
+export const TASK_STAGES: readonly TaskStage[] = ['planning', 'active', 'review']
+
 export interface TaskBoardRow {
   id: string
   ref: string
   domain: string
+  /** Capped to TASK_TITLE_MAX for a lens row. */
   title: string
+  /** The whole description, for surfaces with room. */
+  text: string
+  source?: string
+  owner?: string
+  delegated?: boolean
+  agentState?: 'running' | 'done' | 'failed'
+  agentNo?: number
+  checked: boolean
   column: TaskColumn
   priority: string
   runAt?: string
   section: string
   sectionDay?: string
+  stage: TaskStage
+  /** Absent until someone says what finished looks like. Gates `run`. */
+  doneWhen?: string
   due: boolean
   missed: boolean
   failed: boolean
@@ -389,11 +411,24 @@ export function projectRow(
     ref: row.ref,
     domain: row.domain,
     title: taskTitle(row.description),
+    // `title` stays capped for the lens; `text` is the whole line. The cap is a
+    // G2 row budget and was being applied to every surface, so a Mac window
+    // 1900px wide showed "Send James/John the call recording + recap…". Additive
+    // on purpose: clients through 6.9.451 read `title` and must keep working.
+    text: row.description,
+    ...(row.source ? { source: row.source } : {}),
+    ...(row.owner ? { owner: row.owner } : {}),
+    ...(row.delegated ? { delegated: true } : {}),
+    ...(row.agent_state ? { agentState: row.agent_state } : {}),
+    ...(row.agent_no != null ? { agentNo: row.agent_no } : {}),
+    checked: row.is_checked,
     column: col,
     priority: row.priority,
     ...(runAt ? { runAt: new Date(taskInstant(runAt.day, runAt.minutes, tz)).toISOString() } : {}),
     section: row.section,
     ...(row.section_day ? { sectionDay: row.section_day } : {}),
+    stage: row.stage ?? 'planning',
+    ...(row.done_when ? { doneWhen: row.done_when } : {}),
     ...mark,
   }
 }
@@ -458,6 +493,34 @@ export async function setTaskRunAt(domain: string, id: string, runAt: string | n
   await withLockRetry(() => bridge(args))
 }
 
+/** Rewrite a task's words. The bridge preserves its source block and schedule. */
+export async function setTaskText(domain: string, id: string, text: string): Promise<void> {
+  const clean = text.replace(/\s+/g, ' ').trim()
+  if (!clean) throw new TaskRunError(400, 'text_required', 'text is required')
+  if (clean.length > 2000) throw new TaskRunError(422, 'text_too_long', 'text must be 2000 characters or fewer')
+  await withLockRetry(() => bridge(['task-set-text', domain, id], clean))
+}
+
+/** Move a task between board stages. 'planning' clears the marker. */
+export async function setTaskStage(domain: string, id: string, stage: TaskStage): Promise<void> {
+  if (!TASK_STAGES.includes(stage)) {
+    throw new TaskRunError(422, 'invalid_stage', `stage must be one of ${TASK_STAGES.join(', ')}`)
+  }
+  await withLockRetry(() => bridge(['task-set-stage', domain, id, stage === 'planning' ? '--clear' : stage]))
+}
+
+/** Set or clear the finish line. Empty clears it, which re-blocks `run`. */
+export async function setTaskDoneWhen(domain: string, id: string, text: string): Promise<void> {
+  const clean = text.replace(/\s+/g, ' ').trim()
+  if (clean.length > 500) {
+    throw new TaskRunError(422, 'done_when_too_long', 'done_when must be 500 characters or fewer')
+  }
+  if (clean.includes('**')) {
+    throw new TaskRunError(422, 'invalid_done_when', 'done_when cannot contain ** markup')
+  }
+  await withLockRetry(() => bridge(['task-set-done-when', domain, id], clean))
+}
+
 export async function moveTask(domain: string, id: string, section: string, nowMs = Date.now()): Promise<void> {
   const { clock } = briefContext(nowMs)
   const args = ['task-move', domain, id, '--section', section]

package/server/routes/tasks.ts

@@ -1,7 +1,8 @@
 import { Router } from 'express'
 import { queryJobCoordinator } from '../lib/query-job-runtime.js'
 import { runTaskNow } from '../lib/task-dispatcher.js'
-import { domainAbbreviation } from '../lib/domains.js'
+import { domainAbbreviation, isSafeDomainName } from '../lib/domains.js'
+import { updateProfileFields } from '../lib/profile.js'
 import { domainLabel } from '../lib/domain-label.js'
 import {
   TaskBridgeError,
@@ -14,9 +15,13 @@ import {
   moveTask,
   saveDispatchCap,
   setTaskRunAt,
+  setTaskText,
   taskDomains,
   tasksGate,
   workBadgeCount,
+  setTaskStage,
+  setTaskDoneWhen,
+  type TaskStage,
 } from '../lib/task-store.js'
 
 export const tasksRouter = Router()
@@ -127,6 +132,46 @@ tasksRouter.get('/domains', (_req, res) => {
   }
 })
 
+/** Set the user's domain list. Replaces it wholesale: the client shows the
+ *  current list and sends back what it wants, which is what a settings pane does.
+ *  Discovered folders are NOT written here — they keep showing because the read
+ *  side unions them in, so removing a name from config never hides a folder that
+ *  still holds tasks. */
+tasksRouter.put('/domains', (req, res) => {
+  try {
+    const raw = (req.body ?? {}).domains
+    if (!Array.isArray(raw)) throw new TaskRunError(400, 'domains_required', 'domains must be an array')
+    if (raw.length > 32) throw new TaskRunError(422, 'too_many_domains', 'at most 32 domains')
+    const names: string[] = []
+    const seen = new Set<string>()
+    for (const entry of raw) {
+      const name = typeof entry === 'string'
+        ? entry
+        : (entry && typeof entry === 'object' && typeof (entry as { name?: unknown }).name === 'string')
+          ? (entry as { name: string }).name
+          : ''
+      const trimmed = name.trim()
+      if (!trimmed) continue
+      if (!isSafeDomainName(trimmed)) {
+        throw new TaskRunError(422, 'invalid_domain_name', `not a usable domain name: ${trimmed}`)
+      }
+      const key = trimmed.toLowerCase()
+      if (seen.has(key)) continue
+      seen.add(key)
+      names.push(trimmed)
+    }
+    updateProfileFields({ domains: names })
+    const resolved = taskDomains()
+    res.json({
+      domains: resolved.map(name => ({ name, abbr: domainAbbreviation(name), label: domainLabel(name) })),
+      configured: names,
+      gate: tasksGate(),
+    })
+  } catch (error) {
+    sendError(res, error)
+  }
+})
+
 tasksRouter.get('/tasks', async (req, res) => {
   try {
     const column = typeof req.query.column === 'string' ? req.query.column : undefined
@@ -141,14 +186,20 @@ tasksRouter.patch('/tasks/:id', async (req, res) => {
   try {
     const body = req.body ?? {}
     const domain = requireDomain(body.domain)
-    if ('runAt' in body) {
+    if ('text' in body) {
+      await setTaskText(domain, req.params.id, String(body.text))
+    } else if ('runAt' in body) {
       await setTaskRunAt(domain, req.params.id, body.runAt == null || body.runAt === '' ? null : String(body.runAt))
     } else if ('section' in body) {
       await moveTask(domain, req.params.id, String(body.section))
     } else if ('checked' in body) {
       await checkTask({ domain, id: req.params.id, checked: body.checked === true })
+    } else if ('stage' in body) {
+      await setTaskStage(domain, req.params.id, String(body.stage) as TaskStage)
+    } else if ('doneWhen' in body) {
+      await setTaskDoneWhen(domain, req.params.id, body.doneWhen == null ? '' : String(body.doneWhen))
     } else {
-      throw new TaskRunError(400, 'invalid_patch', 'Expected runAt, section, or checked.')
+      throw new TaskRunError(400, 'invalid_patch', 'Expected text, runAt, section, checked, stage, or doneWhen.')
     }
     res.json({ ok: true })
   } catch (error) {