@lumoai/cli 1.49.0 → 1.50.0

package/assets/skill/SKILL.md

@@ -157,7 +157,8 @@ lumo fidelity show LUM-42 --json
 **Sessions** — see [sessions.md](references/sessions.md)
 
 - `lumo session attach <id>` — bind this session to a task (then run `task context`). **Lifetime lock**: re-attaching to the same task is a no-op; attaching to a _different_ task is refused with 409 — start a new Claude Code session instead. No `--force`, no `session detach`.
-- `lumo session status` — show current binding
+- `lumo session attach --steward <milestone>` — bind this session to a **milestone** as a **STEWARD (governance) session** (LUM-640): plan & accept only. Governance passes (task create/update, criteria set incl. `--human`, deps confirm/dismiss, `verdict --fail` with session provenance, milestone add/remove, all reads); implementation is gated (`lumo verify` → 409 **without burning a round**; moving a task to in_progress assigned to yourself → 409); commits/PRs produced anyway are recorded as milestone-scoped boundary crossings (fail-closed; disposition stays web+human-only, no CLI clear path). Same lifetime lock: same milestone idempotent, any other attach (a task, or a different milestone) → 409; multiple stewards per milestone are fine. See [sessions.md](references/sessions.md)
+- `lumo session status` — show current binding (a task, or the milestone + STEWARD role)
 - End-of-session housekeeping is fully automatic (no command). On DONE the server runs three best-effort silent passes: Layer-1 memory curation, fragment-usage audit, and blocked-tag automation. See [sessions.md](references/sessions.md)
 - Git-suggest at session start (suggests `session attach`, never auto-binds) + Layer-2 project-memory review — see the reference
 
@@ -192,6 +193,7 @@ Don't guess these:
 
 - No `lumo session start` — binding is `lumo session attach <LUM-N>`
 - No `lumo session detach` — the session↔task binding is a lifetime lock; to work on a different task, start a new Claude Code session
+- No steward "role switch" or un-steward — `session attach --steward` is the same lifetime lock on a milestone; a steward session never converts to an implementation session (and there is no CLI path to clear its boundary crossings)
 - No `lumo task delete` — tasks can't be deleted from the CLI (web UI only)
 - No `lumo task artifact edit` — it's `lumo task artifact update`
 - No `lumo auth status` — identity check is `lumo whoami`

package/assets/skill/references/milestones.md

@@ -73,6 +73,8 @@ Accepts UUID or name. With a name, `--project <ref>` is required when the worksp
 
 Prints a key:value header (name, status, **health**, dates, project, description), task counts, and the full task table under the milestone. The `Health:` line shows the same target-date risk light as `milestone list` (`ON-TRACK` / `AT-RISK` / `OVERDUE`, or `-` when none applies).
 
+**Staleness hints (LUM-624):** the `Status:` line is annotated `(stale — task progress indicates <STATUS>; auto-updating)` when the stored status lags the task-derived one (the server self-heals the drift in the background — a re-read shows the corrected status), and the `Target:` line is annotated `(no target date — schedule health unavailable)` for an in-flight milestone with no target date.
+
 It also prints a **Sprint coverage** section (above the task table) listing which
 sprints the milestone's tasks span — each row shows the sprint number, status, name,
 and `done/total` progress — plus an `Unscheduled` line counting milestone tasks not in any
@@ -107,6 +109,8 @@ lumo milestone show 11111111-2222-3333-4444-555555555555
 
 At least one field required.
 
+**Status rolls up automatically (LUM-624):** milestone status follows task completion — PLANNED → ACTIVE when any task starts, → COMPLETED when every task is DONE (stamps `completedAt`, triggers the retro summary), and COMPLETED → ACTIVE when a non-DONE task (re)appears. A manual `--status planned/active/completed` that contradicts task reality gets reconciled back on the next task event or detail read; `--status cancelled` and archived milestones are human terminal choices the rollup never touches. You normally don't need `--status completed` by hand anymore.
+
 ```bash
 lumo milestone update "Q3 Launch" --status active
 lumo milestone update "Q3 Launch" --target 2026-09-15

package/assets/skill/references/sessions.md

@@ -113,12 +113,40 @@ A successful `session attach` also runs a **best-effort team-memory downsync** f
 Error: this session is permanently bound to LUM-7 "Other task". A session works one task for its lifetime — start a new Claude Code session to work on LUM-42.
 ```
 
-There is no `--force` and no `session detach`. To work on a different task, open a new terminal / Claude Code session and run `lumo session attach <new-task>` there.
+There is no `--force` and no `session detach`. To work on a different task, open a new terminal / Claude Code session and run `lumo session attach <new-task>` there. A session already bound as **STEWARD** of a milestone (below) also 409s here — it can never attach a task.
 
 #### When to suggest
 
 If `session attach` returns 409, do not retry or look for a workaround — start a fresh Claude Code session for the target task.
 
+### `lumo session attach --steward <milestone>` — bind as a STEWARD (governance) session (LUM-640)
+
+The **second legal session form**: instead of a task, the session binds a **milestone** and becomes a governance role — it plans and accepts, it never implements.
+
+```bash
+lumo session attach --steward "Agent-Native Milestones"   # by name (case-insensitive)
+lumo session attach --steward agent-native-milestones     # by slug
+lumo session attach --steward cmxyz123...                 # by milestone id
+```
+
+- **Resolution:** exact id → case-insensitive name/slug across the workspace's active milestones. An **ambiguous** name is refused with 400 listing the candidates (retry with the id); no match is 404.
+- **Lifetime lock, same semantics as the task form:** re-attach to the **same** milestone = idempotent no-op; attach a **task** after a steward bind → 409; attach a **different milestone** → 409; a task-bound session running `--steward` → 409. No `--force`, no detach — a different binding needs a new Claude Code session.
+- **Multiple stewards per milestone are allowed** (acceptance is multi-round by nature); sessions don't conflict.
+
+**Allowed (governance — pass through unchanged, with the session recorded as provenance):** `task create` / `task update`, `task criteria set` (incl. `--human`), `task deps confirm/dismiss`, `verdict --fail` (the send-back rows carry `sourceSessionId`), `milestone add/remove`, and **all read operations**.
+
+**Blocked (implementation — first layer, API gate):**
+
+- `lumo verify` → **409, no round burned, no VerificationRun written**. The error names the milestone and the remedy (start an implementation session and `lumo session attach <task>`). Do not retry from the steward session.
+- Moving a task to `in_progress` with **yourself as the effective assignee** (whether already assigned to you or assigned in the same call) → 409. Dispatching to _someone else_ is planning and passes.
+- Red line unchanged: a steward writes no PASS of any kind; DONE stays human-only.
+
+**Backstop (second layer, detector):** commits / PR creations produced during a steward session anyway (the CLI can't stop local git) are recorded as **`STEWARD_IMPLEMENTATION_ARTIFACT` boundary crossings against the milestone** — fail-closed (an unparseable Bash payload records an _unconfirmed_ crossing rather than nothing), disposition stays **web + human-only**, and there is **no CLI clear path** (`crossing explain` remains an appeal, never a clear).
+
+#### When to suggest
+
+The user asks to "review/accept/plan a milestone", to act as reviewer/steward across tasks, or wants a governance session that must not implement. If a steward session needs code changed, dispatch the task to an implementation owner (or tell the user to open a new implementation session) — never work around the gate.
+
 ### Parallel sessions
 
 Each Claude Code session has its own `CLAUDE_CODE_SESSION_ID`. Two terminals running `claude code` and binding to different tasks will not interfere — bindings are scoped per session row server-side.
@@ -129,7 +157,7 @@ Each Claude Code session has its own `CLAUDE_CODE_SESSION_ID`. Two terminals run
 lumo session status
 ```
 
-Prints which task the current Claude Code session is bound to, or "(no task)" if none. Requires `$CLAUDE_CODE_SESSION_ID` (must run inside Claude Code).
+Prints what the current Claude Code session is bound to — a task, a milestone (`Role: STEWARD (governance — plan & accept only)`), or "(no task)" if none. Requires `$CLAUDE_CODE_SESSION_ID` (must run inside Claude Code).
 
 #### When to suggest
 

package/dist/cli/src/commands/milestone-show.js

@@ -44,13 +44,19 @@ function formatMilestoneShow(m, tasks) {
         m.taskCounts.IN_PROGRESS +
         m.taskCounts.IN_REVIEW +
         m.taskCounts.DONE;
+    const statusLine = m.staleness?.statusDrift
+        ? `Status:       ${m.status}  (stale — task progress indicates ${(0, sanitize_1.sanitizeField)(m.staleness.statusDrift)}; auto-updating)`
+        : `Status:       ${m.status}`;
+    const targetLine = m.staleness?.datesMissing
+        ? `Target:       ${fmtDate(m.targetDate)}  (no target date — schedule health unavailable)`
+        : `Target:       ${fmtDate(m.targetDate)}`;
     const lines = [
         `Milestone:    ${(0, sanitize_1.sanitizeField)(m.name)}`,
-        `Status:       ${m.status}`,
+        statusLine,
         `Archived:     ${m.archivedAt ? m.archivedAt.slice(0, 10) : 'no'}`,
         `Health:       ${fmtHealth(m.health)}`,
         `Start:        ${fmtDate(m.startDate)}`,
-        `Target:       ${fmtDate(m.targetDate)}`,
+        targetLine,
         `Project:      ${(0, sanitize_1.sanitizeField)(m.projectName)}`,
         `Description:`,
         `  ${m.description && m.description.length > 0 ? (0, sanitize_1.sanitizeField)(m.description) : '-'}`,
@@ -136,6 +142,7 @@ async function milestoneShow(identifier, opts) {
         projectName,
         taskCounts: milestone.taskCounts,
         health: milestone.health,
+        staleness: milestone.staleness,
         sprintCoverage: milestone.sprintCoverage,
     }, tasks) + '\n');
 }

package/dist/cli/src/commands/session-attach.js

@@ -7,21 +7,30 @@ const sanitize_1 = require("../lib/sanitize");
 const resolve_project_1 = require("../lib/resolve-project");
 const memory_auto_1 = require("../lib/memory-auto");
 /**
- * `lumo session attach <identifier>` — bind the currently-running
- * Claude Code session to a task.
+ * `lumo session attach <identifier> [--steward]` — bind the currently-running
+ * Claude Code session to a task, or (with `--steward`) to a MILESTONE as a
+ * STEWARD (governance) session (LUM-640).
  *
  * Required environment: `CLAUDE_CODE_SESSION_ID` (set automatically by
  * Claude Code). Must be invoked from inside a Claude Code session.
  *
- * The binding is a **lifetime lock** (LUM-459): `Session.taskId` is write-once.
- * Re-attaching to the *same* task is an idempotent no-op (re-emits context).
- * Attaching to a *different* task is refused with HTTP 409 — there is no
- * `--force` and no `session detach`; a different task requires a brand-new
- * Claude Code session.
+ * Both forms are a **lifetime lock** (LUM-459/LUM-640): the binding is
+ * write-once. Re-attaching to the *same* task/milestone is an idempotent
+ * no-op. Attaching to anything else — a different task, a different
+ * milestone, a task after a steward bind, a milestone after a task bind —
+ * is refused with HTTP 409; there is no `--force` and no `session detach`;
+ * a different binding requires a brand-new Claude Code session.
+ *
+ * A STEWARD session plans and accepts only: task create/update, criteria
+ * set, deps confirm/dismiss, verdict --fail, milestone add/remove and all
+ * reads pass; `lumo verify` and self-dispatch are refused with 409, and
+ * implementation artifacts (commits/PRs) are recorded as boundary crossings.
  */
-async function sessionAttach(identifier) {
+async function sessionAttach(identifier, options) {
     if (!identifier) {
-        console.error('Error: missing <identifier>. Usage: lumo session attach <LUM-42>');
+        console.error(options?.steward
+            ? 'Error: missing <identifier>. Usage: lumo session attach --steward <milestone id | name | slug>'
+            : 'Error: missing <identifier>. Usage: lumo session attach <LUM-42>');
         return 1;
     }
     const sessionId = process.env.CLAUDE_CODE_SESSION_ID;
@@ -35,6 +44,14 @@ async function sessionAttach(identifier) {
         console.error('Error: not logged in. Run `lumo auth login` first.');
         return 1;
     }
+    if (options?.steward) {
+        return stewardAttach({
+            identifier,
+            sessionId,
+            apiUrl: (0, api_1.resolveAuthedApiUrl)(creds.apiUrl),
+            token: creds.token,
+        });
+    }
     const apiUrl = (0, api_1.resolveAuthedApiUrl)(creds.apiUrl);
     const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-task`;
     let res;
@@ -70,12 +87,17 @@ async function sessionAttach(identifier) {
         console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)}`);
         return 1;
     }
-    // Lifetime lock (LUM-459): the session is permanently bound to another task.
+    // Lifetime lock (LUM-459): the session is permanently bound to another task —
+    // or (LUM-640) it is a STEWARD session bound to a milestone.
     if (res.status === 409) {
         let current = 'another task';
+        let stewardMilestone = null;
         try {
             const data = (await res.json());
-            if (data.currentTaskIdentifier) {
+            if (data.currentMilestoneName) {
+                stewardMilestone = (0, sanitize_1.sanitizeField)(data.currentMilestoneName);
+            }
+            else if (data.currentTaskIdentifier) {
                 current = data.currentTaskTitle
                     ? `${data.currentTaskIdentifier} "${(0, sanitize_1.sanitizeField)(data.currentTaskTitle)}"`
                     : data.currentTaskIdentifier;
@@ -84,6 +106,12 @@ async function sessionAttach(identifier) {
         catch {
             // fall through with the generic phrasing
         }
+        if (stewardMilestone) {
+            console.error(`Error: this session is a STEWARD (governance) session for milestone "${stewardMilestone}" — ` +
+                'it cannot attach a task. Start a new Claude Code session to ' +
+                `implement ${identifier}.`);
+            return 1;
+        }
         console.error(`Error: this session is permanently bound to ${current}. ` +
             'A session works one task for its lifetime — start a new Claude Code ' +
             `session to work on ${identifier}.`);
@@ -139,3 +167,75 @@ async function sessionAttach(identifier) {
         // best-effort — the bind already succeeded; never surface a sync error here
     }
 }
+/**
+ * LUM-640: the `--steward` form — bind this session to a MILESTONE as a
+ * governance session. Same lifetime-lock error surface as the task form; the
+ * success output spells out the allowed/blocked action split so the agent
+ * knows its lane without a round-trip to the docs.
+ */
+async function stewardAttach(args) {
+    const { identifier, sessionId, apiUrl, token } = args;
+    const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-milestone`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ milestoneRef: identifier }),
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: could not reach Lumo API at ${apiUrl} (${msg})`);
+        return 1;
+    }
+    if (res.status === 401) {
+        console.error('Error: API key invalid or revoked. Run `lumo auth login`.');
+        return 1;
+    }
+    // 400 (ambiguous reference) and 404 (no match) carry actionable server
+    // messages — print them verbatim (sanitized).
+    if (res.status === 400 || res.status === 404) {
+        let message = res.status === 404 ? 'Not found' : 'Bad request';
+        try {
+            const data = (await res.json());
+            if (data.error)
+                message = data.error;
+        }
+        catch {
+            // fall through
+        }
+        console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)}`);
+        return 1;
+    }
+    // Lifetime lock: already task-bound, or steward of a different milestone.
+    if (res.status === 409) {
+        let message = 'this session is already permanently bound';
+        try {
+            const data = (await res.json());
+            if (data.error)
+                message = data.error;
+        }
+        catch {
+            // fall through with the generic phrasing
+        }
+        console.error(`Error: ${(0, sanitize_1.sanitizeField)(message)} ` +
+            'A session holds one binding for its lifetime — start a new Claude ' +
+            'Code session for a different task or milestone.');
+        return 1;
+    }
+    if (!res.ok) {
+        console.error(`Error: bind-milestone failed (HTTP ${res.status})`);
+        return 1;
+    }
+    const body = (await res.json());
+    console.log(`Attached session ${sessionId} as STEWARD of milestone "${(0, sanitize_1.sanitizeField)(body.milestoneName)}"`);
+    console.log('');
+    console.log('Governance role — plan & accept only (lifetime lock):');
+    console.log('  allowed: task create/update · criteria set (incl. --human) · deps confirm/dismiss · verdict --fail · milestone add/remove · all reads');
+    console.log('  blocked: lumo verify (409, no round burned) · moving a task to in_progress assigned to yourself · attaching a task');
+    console.log('  note:    commits/PRs produced in this session are recorded as boundary crossings (human-reviewed on the web)');
+}

package/dist/cli/src/commands/session-status.js

@@ -45,6 +45,14 @@ async function sessionStatus() {
         return 1;
     }
     const data = (await res.json());
+    // LUM-640: the steward form — milestone-bound governance session.
+    if (data.role === 'STEWARD' && data.milestoneName) {
+        process.stdout.write(`Session ${sessionId}\n` +
+            `  Role:      STEWARD (governance — plan & accept only)\n` +
+            `  Bound to:  milestone "${(0, sanitize_1.sanitizeField)(data.milestoneName)}"\n` +
+            `  Events:    ${data.eventCount}\n`);
+        return;
+    }
     if (data.taskIdentifier && data.taskTitle) {
         process.stdout.write(`Session ${sessionId}\n` +
             `  Bound to:  ${data.taskIdentifier} "${(0, sanitize_1.sanitizeField)(data.taskTitle)}"\n` +

package/dist/cli/src/index.js

@@ -299,11 +299,12 @@ const session = program
     .description('Manage per-terminal coding-session context');
 session
     .command('attach <identifier>')
-    .description('Attach the currently-running Claude Code session (CLAUDE_CODE_SESSION_ID) to a task. The binding is a lifetime lock: re-attaching to the same task is a no-op, attaching to a different task is refused — start a new session for a different task.')
-    .action(wrap(identifier => (0, session_attach_1.sessionAttach)(identifier)));
+    .description('Attach the currently-running Claude Code session (CLAUDE_CODE_SESSION_ID) to a task — or, with --steward, to a MILESTONE as a governance session (LUM-640: plan/accept only). Either binding is a lifetime lock: re-attaching the same target is a no-op, anything else is refused — start a new session instead.')
+    .option('--steward', 'Bind as a STEWARD (governance) session to a milestone (id, name, or slug) instead of a task. Steward sessions plan and accept only: lumo verify is refused (409, no round burned), self-dispatch to in_progress is refused, and implementation commits/PRs are recorded as boundary crossings.')
+    .action(wrap((identifier, options) => (0, session_attach_1.sessionAttach)(identifier, options)));
 session
     .command('status')
-    .description('Show the task currently bound to this Claude Code session (or "no task" if none).')
+    .description('Show what this Claude Code session is bound to: a task, a milestone (STEWARD governance session), or nothing.')
     .action(wrap(() => (0, session_status_1.sessionStatus)()));
 const task = program
     .command('task')

package/dist/shared/src/gate-map.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Static gate map (LUM-614) — the single source of truth that classifies the
+ * engineer-facing mechanical gates into a stable key set, splits them by how
+ * their signal is produced, and (for execution gates) carries the command
+ * patterns that recognize an executed check in the hook-event stream.
+ *
+ * Shared by the read-model that derives a delivery's gate audit (server) and
+ * the delivery-card panel that renders it (app). It deliberately carries NO
+ * status — status is derived per delivery from HookEvent rows, never stored.
+ *
+ * The class → provenance split seeds the fidelity independence axis: a detection
+ * gate is something Lumo derives itself from the tool-intent stream it already
+ * ingests (independent of the agent). An execution gate's signal can come from
+ * EITHER source: the agent's own tool runs (self-reported — it chose to run the
+ * check and could skip it) OR, as of LUM-616, an independent CI run read back
+ * from GitHub (check-runs / commit-statuses), which the agent cannot skip or
+ * fake. So execution-gate provenance is no longer a pure function of class — it
+ * is carried per produced signal (see NormalizedGateEvent.provenance in the
+ * gate-audit read-model); `provenanceForClass` is only the not-run/not-configured
+ * default. Detection-gate provenance is still class-fixed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GATE_DEFINITIONS = exports.ALL_GATE_KEYS = void 0;
+exports.provenanceForClass = provenanceForClass;
+exports.gateDefinition = gateDefinition;
+exports.classifyCommand = classifyCommand;
+exports.classifyGateName = classifyGateName;
+/** Provenance is a pure function of class — the only place the mapping lives. */
+function provenanceForClass(cls) {
+    return cls === 'detection' ? 'independent_harness' : 'agent_self_reported';
+}
+const RAW_DEFINITIONS = [
+    // 'parse' (node --check) was dropped (LUM-616 follow-up): it's a strict subset
+    // of typecheck/build (which both parse before they can run), so a separate
+    // parse gate carried no independent information and was never sourced — it sat
+    // perpetually not_run. Removed rather than fabricated-green.
+    {
+        key: 'typecheck',
+        class: 'execution',
+        // No build-exclusion lookahead: classification is one-command → N gates
+        // (LUM-629), so `tsc && npm run build` reports typecheck AND build instead
+        // of needing build to win a single-choice tie.
+        commandPatterns: [/\btsc\b/, /typecheck/],
+    },
+    {
+        key: 'build',
+        class: 'execution',
+        commandPatterns: [/\bnext\s+build\b/, /\bnpm\s+run\s+build\b/],
+    },
+    {
+        key: 'test',
+        class: 'execution',
+        commandPatterns: [/\bjest\b/, /\bvitest\b/, /\bnpm\s+(run\s+)?test\b/],
+    },
+    // Detection-class gates were all removed (LUM-616 follow-up): detection belongs
+    // in boundary crossings, not audit-only gates.
+    //  - 'git-hygiene' (committed secrets) ≡ the HARDCODED_SECRET crossing, which
+    //    is detected server-side, surfaced, AND blocks DONE — strictly stronger.
+    //  - 'diff-scope' (out-of-declared-scope edits) has no source of truth yet
+    //    (Lumo has no "declared scope"); the right home is a future
+    //    OUT_OF_SCOPE_EDIT crossing, not a perpetually not_configured gate.
+    // The 'detection' GateClass stays as scaffolding for a clean future re-add.
+];
+const DEFINITIONS = RAW_DEFINITIONS.reduce((acc, raw) => {
+    acc[raw.key] = { ...raw, provenance: provenanceForClass(raw.class) };
+    return acc;
+}, {});
+exports.ALL_GATE_KEYS = RAW_DEFINITIONS.map(d => d.key);
+exports.GATE_DEFINITIONS = exports.ALL_GATE_KEYS.map(k => DEFINITIONS[k]);
+/** Look up a gate's definition by key. */
+function gateDefinition(key) {
+    return DEFINITIONS[key];
+}
+/**
+ * Strip double- and single-quoted substrings from a command line, leaving only
+ * the unquoted invocation tokens. This is what stops a gate keyword that merely
+ * appears inside an *argument* — e.g. a `lumo task create "…parse/typecheck/
+ * build/test…"` description, or `echo "…run the test…"` — from being mistaken
+ * for an invocation of that gate (the LUM-614 prod false-positive, where a
+ * task-create description was classified as a passed typecheck and overwrote
+ * the real `tsc` signal). A real gate run names its tool unquoted, so it
+ * survives the strip.
+ */
+function unquotedInvocation(command) {
+    return command.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g, ' ');
+}
+/**
+ * Classify an executed shell command as execution gates — EVERY gate whose
+ * invocation tokens the command hits, in declaration order; empty when none.
+ * One command → N gates (LUM-629): agents routinely chain checks in a single
+ * shell line (`npx jest …; npx tsc --noEmit`), and single-choice classification
+ * silently dropped all but one gate's signal (the LUM-620 #770 test=not_run
+ * under-report). Matching still runs against the unquoted invocation only, so
+ * a gate keyword buried in quoted argument text never produces a false signal
+ * (LUM-614). Detection gates are never returned here — they're not derived
+ * from commands.
+ */
+function classifyCommand(command) {
+    const invocation = unquotedInvocation(command);
+    return exports.GATE_DEFINITIONS.filter(def => def.commandPatterns.some(p => p.test(invocation))).map(def => def.key);
+}
+/**
+ * Patterns that classify a CI check-run / commit-status NAME (not a shell
+ * command) as an execution gate. LUM-616: the independent harness reads CI
+ * signals straight from GitHub (check-runs + commit-statuses) across ANY
+ * provider, and the only semantics GitHub exposes is each check's name plus its
+ * pass/fail — so mapping a named check to a gate is unavoidably name-based.
+ * Platform-agnostic on purpose (GitHub Actions, Vercel, CircleCI, Travis, …).
+ * First match wins; order = most specific (typecheck/test) before the build
+ * catch-all so a "build and test" job lands on the narrower gate.
+ */
+const CHECK_NAME_PATTERNS = [
+    ['typecheck', [/\btypecheck\b/i, /\btsc\b/i, /type[\s-]?check/i]],
+    ['test', [/\btests?\b/i, /\bjest\b/i, /\bvitest\b/i, /\bspec\b/i]],
+    ['build', [/\bbuild\b/i, /\bvercel\b/i, /\bdeploy/i]],
+];
+/**
+ * Classify a CI check / commit-status name as an execution gate, or null when
+ * it matches none — an unrecognized check is dropped, never coerced into a
+ * fabricated gate. A name carrying "comment" (e.g. "Vercel Preview Comments")
+ * is a bot annotation, not a CI check, and is rejected before pattern matching.
+ */
+function classifyGateName(name) {
+    const n = name.trim();
+    if (!n || /comment/i.test(n))
+        return null;
+    for (const [key, patterns] of CHECK_NAME_PATTERNS) {
+        if (patterns.some(p => p.test(n)))
+            return key;
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumoai/cli",
-  "version": "1.49.0",
+  "version": "1.50.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",