@brainervirus/workit-cli 8.19.1 → 8.20.0

package/dist/index.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.19.1",
+    version: "8.20.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -103,13 +103,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.19.1",
+      "@brainervirus/workit-cursor": "^8.20.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.19.1"
+      "@brainervirus/workit-core": "^8.20.0"
     },
     engines: {
       node: ">=24"
@@ -117,55 +117,6 @@ var init_package = __esm(() => {
   };
 });
 
-// packages/workit-cli/src/output.ts
-function emit(io, envelope, human) {
-  if (io.json) {
-    io.stdout(`${JSON.stringify(envelope)}
-`);
-  } else if (envelope.ok) {
-    const text = human?.(envelope.data);
-    const lines = typeof text === "string" ? [text] : text ?? [];
-    for (const value of lines)
-      io.stdout(`${value}
-`);
-  } else {
-    io.stderr(`workit: ${envelope.error ?? envelope.code}
-`);
-    if (envelope.unblock)
-      io.stderr(`  unblock: ${envelope.unblock}
-`);
-  }
-  return exitCodeFor(envelope.code);
-}
-var EXIT, EXIT_BY_CODE, exitCodeFor = (code) => EXIT_BY_CODE[code], ok = (data) => ({ ok: true, code: "ok", data }), fail = (code, error, extra = {}) => ({
-  ok: false,
-  code,
-  data: extra.data ?? {},
-  error,
-  ...extra.unblock ? { unblock: extra.unblock } : {}
-});
-var init_output = __esm(() => {
-  EXIT = {
-    ok: 0,
-    failed: 1,
-    usage: 2,
-    blocked: 3,
-    busy: 4,
-    unavailable: 5
-  };
-  EXIT_BY_CODE = {
-    ok: EXIT.ok,
-    failed: EXIT.failed,
-    not_found: EXIT.failed,
-    invalid_input: EXIT.usage,
-    not_implemented: EXIT.usage,
-    blocked: EXIT.blocked,
-    busy: EXIT.busy,
-    pending: EXIT.busy,
-    unavailable: EXIT.unavailable
-  };
-});
-
 // packages/workit-core/src/check-config.ts
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
@@ -21482,7 +21433,7 @@ function resolveInside(root, candidate) {
   }
   return target;
 }
-var ok2 = (data) => ({ ok: true, data, error: null }), fail2 = (error, data = null) => ({
+var ok = (data) => ({ ok: true, data, error: null }), fail = (error, data = null) => ({
   ok: false,
   data,
   error
@@ -21604,6 +21555,12 @@ async function parseTaskArgs(argv, deps) {
         json = true;
       continue;
     }
+    if (family === "task" && action === "list" && token === "--status") {
+      const value = inline ?? argv[++i];
+      if (value !== "all")
+        return parseUsage(`task list has no status filter (got --status ${value ?? ""}); it lists every task`, json);
+      continue;
+    }
     if (takesWorkerId && workerId === undefined && !argv[i].startsWith("-")) {
       workerId = argv[i];
       continue;
@@ -21885,6 +21842,55 @@ var init_task = __esm(() => {
   };
 });
 
+// packages/workit-cli/src/output.ts
+function emit(io, envelope, human) {
+  if (io.json) {
+    io.stdout(`${JSON.stringify(envelope)}
+`);
+  } else if (envelope.ok) {
+    const text = human?.(envelope.data);
+    const lines = typeof text === "string" ? [text] : text ?? [];
+    for (const value of lines)
+      io.stdout(`${value}
+`);
+  } else {
+    io.stderr(`workit: ${envelope.error ?? envelope.code}
+`);
+    if (envelope.unblock)
+      io.stderr(`  unblock: ${envelope.unblock}
+`);
+  }
+  return exitCodeFor(envelope.code);
+}
+var EXIT, EXIT_BY_CODE, exitCodeFor = (code) => EXIT_BY_CODE[code], ok2 = (data) => ({ ok: true, code: "ok", data }), fail2 = (code, error, extra = {}) => ({
+  ok: false,
+  code,
+  data: extra.data ?? {},
+  error,
+  ...extra.unblock ? { unblock: extra.unblock } : {}
+});
+var init_output = __esm(() => {
+  EXIT = {
+    ok: 0,
+    failed: 1,
+    usage: 2,
+    blocked: 3,
+    busy: 4,
+    unavailable: 5
+  };
+  EXIT_BY_CODE = {
+    ok: EXIT.ok,
+    failed: EXIT.failed,
+    not_found: EXIT.failed,
+    invalid_input: EXIT.usage,
+    not_implemented: EXIT.usage,
+    blocked: EXIT.blocked,
+    busy: EXIT.busy,
+    pending: EXIT.busy,
+    unavailable: EXIT.unavailable
+  };
+});
+
 // packages/workit-cli/src/verbs/task.ts
 function isImplicitTaskForm(argv) {
   const [action, ...rest] = argv;
@@ -21929,7 +21935,7 @@ async function run(argv, io) {
   const [action, ...rest] = argv;
   const flags = parse4(rest);
   if (flags instanceof Error)
-    return emit(io, fail("invalid_input", flags.message, { unblock: USAGE }));
+    return emit(io, fail2("invalid_input", flags.message, { unblock: USAGE }));
   await Promise.resolve().then(() => init_core3());
   const root = rootFor(io);
   const store = new TaskStore(root);
@@ -21951,7 +21957,7 @@ async function run(argv, io) {
   };
   const key = store.currentKey();
   if (!key.ok)
-    return emit(io, fail("unavailable", key.error));
+    return emit(io, fail2("unavailable", key.error));
   const where = key.data.branch ? `branch ${key.data.branch}` : key.data.key;
   if (action === "status") {
     if (flags.switches.has("--all")) {
@@ -21968,7 +21974,7 @@ async function run(argv, io) {
         progress: entry.progress,
         current: entry.key === key.data.key && entry.status !== "closed"
       }));
-      return emit(io, ok({ key: key.data, tasks }), (data) => data.tasks.length ? data.tasks.map((task) => `${task.current ? "*" : " "} ${task.id} ${task.status}${task.key ? ` [${task.key}]` : task.legacy ? " [2.x; adopt with workit task adopt <id>]" : ""} — ${task.objective}`) : ["no tasks in this store"]);
+      return emit(io, ok2({ key: key.data, tasks }), (data) => data.tasks.length ? data.tasks.map((task) => `${task.current ? "*" : " "} ${task.id} ${task.status}${task.key ? ` [${task.key}]` : task.legacy ? " [2.x; adopt with workit task adopt <id>]" : ""} — ${task.objective}`) : ["no tasks in this store"]);
     }
     const found = store.implicitTask({ provenance, create: false });
     if (!found.ok)
@@ -21985,7 +21991,7 @@ async function run(argv, io) {
         });
     const noteLines = notes.map((note) => `duplicate open task ${note.id} on ${note.key} (not used); close it: ${note.hint}`);
     if (!found.data)
-      return emit(io, ok({ key: key.data, task: null, notes }), () => [
+      return emit(io, ok2({ key: key.data, task: null, notes }), () => [
         `no task for ${where} yet; it is created by the first note, check or recording (or: workit task start "<objective>")`,
         ...noteLines
       ]);
@@ -21998,7 +22004,7 @@ async function run(argv, io) {
     if (!summary.ok)
       return engineFailure(io, summary);
     const task = found.data.task;
-    return emit(io, ok({ key: key.data, task: summary.data, notes }), () => [
+    return emit(io, ok2({ key: key.data, task: summary.data, notes }), () => [
       `${task.id} ${task.status} — ${task.intent.data.objective} (${where})`,
       ...task.progress.summary ? [`progress: ${task.progress.summary}`] : [],
       ...task.progress.nextAction ? [`next: ${task.progress.nextAction}`] : [],
@@ -22009,7 +22015,7 @@ async function run(argv, io) {
   if (action === "start" || action === "note") {
     const text = flags.positionals.join(" ").trim();
     if (!text)
-      return emit(io, fail("invalid_input", `task ${action} needs ${action === "start" ? "an objective" : "a note"}`, {
+      return emit(io, fail2("invalid_input", `task ${action} needs ${action === "start" ? "an objective" : "a note"}`, {
         unblock: USAGE
       }));
     const objective = action === "start" ? text : flags.values.get("--objective") ?? undefined;
@@ -22048,7 +22054,7 @@ async function run(argv, io) {
     const latest = store.readTask(task.id);
     if (latest.ok)
       task = latest.data;
-    return emit(io, ok({
+    return emit(io, ok2({
       key: key.data,
       created: found.data.created,
       task: {
@@ -22063,12 +22069,12 @@ async function run(argv, io) {
     const outcomeFlag = flags.values.get("--outcome") ?? "verified";
     const outcome = OUTCOMES[outcomeFlag];
     if (!outcome)
-      return emit(io, fail("invalid_input", "--outcome is verified, limited or stopped", { unblock: USAGE }));
+      return emit(io, fail2("invalid_input", "--outcome is verified, limited or stopped", { unblock: USAGE }));
     const found = store.implicitTask({ provenance, create: false });
     if (!found.ok)
       return engineFailure(io, found);
     if (!found.data)
-      return emit(io, fail("not_found", `no open task for ${where}`));
+      return emit(io, fail2("not_found", `no open task for ${where}`));
     const task = found.data.task;
     const summary = flags.values.get("--summary") ?? (task.progress.summary || `closed (${outcomeFlag})`);
     return runTaskCommand([
@@ -22085,15 +22091,15 @@ async function run(argv, io) {
   if (action === "adopt") {
     const [id] = flags.positionals;
     if (!id || flags.positionals.length !== 1)
-      return emit(io, fail("invalid_input", "task adopt takes one task id", { unblock: USAGE }));
+      return emit(io, fail2("invalid_input", "task adopt takes one task id", { unblock: USAGE }));
     const adopted = store.adoptTask(id);
     if (!adopted.ok)
       return engineFailure(io, adopted, "workit task status --all");
-    return emit(io, ok({ key: key.data, task: { id: adopted.data.id, status: adopted.data.status } }), () => `${adopted.data.id} now tracks ${where}`);
+    return emit(io, ok2({ key: key.data, task: { id: adopted.data.id, status: adopted.data.status } }), () => `${adopted.data.id} now tracks ${where}`);
   }
-  return emit(io, fail("invalid_input", `unknown task action ${action ?? ""}`, { unblock: USAGE }));
+  return emit(io, fail2("invalid_input", `unknown task action ${action ?? ""}`, { unblock: USAGE }));
 }
-var USAGE = 'workit task status [--all] | task start "<objective>" | task note "<text>" [--next "<t>"] [--objective "<t>"] | task close [--outcome verified|limited|stopped] [--summary "<t>"] [--confirm] | task adopt <id>', IMPLICIT2, VALUE_FLAGS, SWITCHES, ENGINE_CODES, engineFailure = (io, result, unblock) => emit(io, fail(ENGINE_CODES[result.code] ?? "failed", `${result.code}: ${result.error}`, {
+var USAGE = 'workit task status [--all] | task start "<objective>" | task note "<text>" [--next "<t>"] [--objective "<t>"] | task close [--outcome verified|limited|stopped] [--summary "<t>"] [--confirm] | task adopt <id>', IMPLICIT2, VALUE_FLAGS, SWITCHES, ENGINE_CODES, engineFailure = (io, result, unblock) => emit(io, fail2(ENGINE_CODES[result.code] ?? "failed", `${result.code}: ${result.error}`, {
   data: { code: result.code },
   ...unblock ? { unblock } : result.code === "busy" ? { unblock: "retry the same command" } : {}
 })), OUTCOMES, rootFor = (io) => io.env.WORKFLOW_WORKSPACE_ROOT || checkRoot(io.cwd);
@@ -36767,7 +36773,7 @@ function getSgrPrefix(code) {
   if (code.startsWith("›")) {
     return "›";
   }
-  return `${ESCAPE2}${ANSI_CSI2}`;
+  return `${ESCAPE}${ANSI_CSI2}`;
 }
 function createSgrCode(prefix, values) {
   return `${prefix}${values.join(";")}${ANSI_SGR_TERMINATOR2}`;
@@ -36776,7 +36782,7 @@ function getSgrFragments(code) {
   const fragments = [];
   const sgrPrefix = getSgrPrefix(code);
   let parameterString;
-  if (code.startsWith(`${ESCAPE2}${ANSI_CSI2}`)) {
+  if (code.startsWith(`${ESCAPE}${ANSI_CSI2}`)) {
     parameterString = code.slice(2, -1);
   } else if (code.startsWith("›")) {
     parameterString = code.slice(1, -1);
@@ -36937,7 +36943,7 @@ function parseHyperlinkCode(string, index) {
         endIndex: sequenceIndex + 1
       };
     }
-    if (character === ESCAPE2 && string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR) {
+    if (character === ESCAPE && string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR) {
       const code = string.slice(index, sequenceIndex + 2);
       const action = sequenceIndex === uriStart + 1 ? "close" : "open";
       return {
@@ -37020,7 +37026,7 @@ function parseControlStringCode(string, index) {
     if (supportsBellTerminator && string[sequenceIndex] === ANSI_BELL) {
       return createControlParseResult(string.slice(index, sequenceIndex + 1), sequenceIndex + 1);
     }
-    if (string[sequenceIndex] === ESCAPE2 && string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR) {
+    if (string[sequenceIndex] === ESCAPE && string[sequenceIndex + 1] === ANSI_OSC_TERMINATOR) {
       return createControlParseResult(string.slice(index, sequenceIndex + 2), sequenceIndex + 2);
     }
     if (string[sequenceIndex] === C1_STRING_TERMINATOR) {
@@ -37245,7 +37251,7 @@ function tokenizeAnsi(string, { endCharacter = Number.POSITIVE_INFINITY } = {})
   }
   return tokens;
 }
-var ESCAPE_CODE_POINT = 27, C1_DCS_CODE_POINT = 144, C1_SOS_CODE_POINT = 152, C1_CSI_CODE_POINT = 155, C1_ST_CODE_POINT = 156, C1_OSC_CODE_POINT = 157, C1_PM_CODE_POINT = 158, C1_APC_CODE_POINT = 159, ESCAPES2, ESCAPE2 = "\x1B", ANSI_BELL = "\x07", ANSI_CSI2 = "[", ANSI_OSC2 = "]", ANSI_DCS = "P", ANSI_SOS = "X", ANSI_PM = "^", ANSI_APC = "_", ANSI_SGR_TERMINATOR2 = "m", ANSI_OSC_TERMINATOR = "\\", ANSI_STRING_TERMINATOR, C1_OSC = "", C1_STRING_TERMINATOR = "œ", ANSI_HYPERLINK_ESC_PREFIX, ANSI_HYPERLINK_C1_PREFIX, ANSI_HYPERLINK_ESC_CLOSE, ANSI_HYPERLINK_C1_CLOSE, CODE_POINT_0, CODE_POINT_9, CODE_POINT_SEMICOLON, CODE_POINT_COLON, CODE_POINT_CSI_PARAMETER_START, CODE_POINT_CSI_PARAMETER_END, CODE_POINT_CSI_INTERMEDIATE_START, CODE_POINT_CSI_INTERMEDIATE_END, CODE_POINT_CSI_FINAL_START, CODE_POINT_CSI_FINAL_END, REGIONAL_INDICATOR_SYMBOL_LETTER_A = 127462, REGIONAL_INDICATOR_SYMBOL_LETTER_Z = 127487, SGR_RESET_CODE = 0, SGR_EXTENDED_FOREGROUND_CODE = 38, SGR_DEFAULT_FOREGROUND_CODE = 39, SGR_EXTENDED_BACKGROUND_CODE = 48, SGR_DEFAULT_BACKGROUND_CODE = 49, SGR_COLOR_TYPE_ANSI_256 = 5, SGR_COLOR_TYPE_TRUECOLOR = 2, SGR_ANSI_256_FRAGMENT_LENGTH = 3, SGR_TRUECOLOR_FRAGMENT_LENGTH = 5, SGR_ANSI_256_LAST_PARAMETER_OFFSET = 2, SGR_TRUECOLOR_LAST_PARAMETER_OFFSET = 4, VARIATION_SELECTOR_16_CODE_POINT = 65039, COMBINING_ENCLOSING_KEYCAP_CODE_POINT = 8419, EMOJI_PRESENTATION_GRAPHEME_REGEX, GRAPHEME_SEGMENTER, endCodeNumbers;
+var ESCAPE_CODE_POINT = 27, C1_DCS_CODE_POINT = 144, C1_SOS_CODE_POINT = 152, C1_CSI_CODE_POINT = 155, C1_ST_CODE_POINT = 156, C1_OSC_CODE_POINT = 157, C1_PM_CODE_POINT = 158, C1_APC_CODE_POINT = 159, ESCAPES2, ESCAPE = "\x1B", ANSI_BELL = "\x07", ANSI_CSI2 = "[", ANSI_OSC2 = "]", ANSI_DCS = "P", ANSI_SOS = "X", ANSI_PM = "^", ANSI_APC = "_", ANSI_SGR_TERMINATOR2 = "m", ANSI_OSC_TERMINATOR = "\\", ANSI_STRING_TERMINATOR, C1_OSC = "", C1_STRING_TERMINATOR = "œ", ANSI_HYPERLINK_ESC_PREFIX, ANSI_HYPERLINK_C1_PREFIX, ANSI_HYPERLINK_ESC_CLOSE, ANSI_HYPERLINK_C1_CLOSE, CODE_POINT_0, CODE_POINT_9, CODE_POINT_SEMICOLON, CODE_POINT_COLON, CODE_POINT_CSI_PARAMETER_START, CODE_POINT_CSI_PARAMETER_END, CODE_POINT_CSI_INTERMEDIATE_START, CODE_POINT_CSI_INTERMEDIATE_END, CODE_POINT_CSI_FINAL_START, CODE_POINT_CSI_FINAL_END, REGIONAL_INDICATOR_SYMBOL_LETTER_A = 127462, REGIONAL_INDICATOR_SYMBOL_LETTER_Z = 127487, SGR_RESET_CODE = 0, SGR_EXTENDED_FOREGROUND_CODE = 38, SGR_DEFAULT_FOREGROUND_CODE = 39, SGR_EXTENDED_BACKGROUND_CODE = 48, SGR_DEFAULT_BACKGROUND_CODE = 49, SGR_COLOR_TYPE_ANSI_256 = 5, SGR_COLOR_TYPE_TRUECOLOR = 2, SGR_ANSI_256_FRAGMENT_LENGTH = 3, SGR_TRUECOLOR_FRAGMENT_LENGTH = 5, SGR_ANSI_256_LAST_PARAMETER_OFFSET = 2, SGR_TRUECOLOR_LAST_PARAMETER_OFFSET = 4, VARIATION_SELECTOR_16_CODE_POINT = 65039, COMBINING_ENCLOSING_KEYCAP_CODE_POINT = 8419, EMOJI_PRESENTATION_GRAPHEME_REGEX, GRAPHEME_SEGMENTER, endCodeNumbers;
 var init_tokenize_ansi = __esm(() => {
   init_ansi_styles();
   init_is_fullwidth_code_point();
@@ -37259,8 +37265,8 @@ var init_tokenize_ansi = __esm(() => {
     C1_PM_CODE_POINT,
     C1_APC_CODE_POINT
   ]);
-  ANSI_STRING_TERMINATOR = `${ESCAPE2}${ANSI_OSC_TERMINATOR}`;
-  ANSI_HYPERLINK_ESC_PREFIX = `${ESCAPE2}${ANSI_OSC2}8;`;
+  ANSI_STRING_TERMINATOR = `${ESCAPE}${ANSI_OSC_TERMINATOR}`;
+  ANSI_HYPERLINK_ESC_PREFIX = `${ESCAPE}${ANSI_OSC2}8;`;
   ANSI_HYPERLINK_C1_PREFIX = `${C1_OSC}8;`;
   ANSI_HYPERLINK_ESC_CLOSE = `${ANSI_HYPERLINK_ESC_PREFIX};`;
   ANSI_HYPERLINK_C1_CLOSE = `${ANSI_HYPERLINK_C1_PREFIX};`;
@@ -73094,7 +73100,7 @@ __export(exports_init, {
 });
 async function run3(_argv, io) {
   if (io.json)
-    return emit(io, fail("invalid_input", "workit init is an interactive wizard and has no --json output", {
+    return emit(io, fail2("invalid_input", "workit init is an interactive wizard and has no --json output", {
       unblock: "run `workit init` in a terminal without --json"
     }));
   await init_src2();
@@ -73982,7 +73988,7 @@ async function run6(argv, io) {
     if (!confirmed) {
       if (!io.json)
         return 3;
-      return emit(io, fail("blocked", "fix-lock --force: refusing without --yes outside an interactive terminal", {
+      return emit(io, fail2("blocked", "fix-lock --force: refusing without --yes outside an interactive terminal", {
         data: { lock: inspectMetadataLock(root) },
         unblock: "workit doctor --fix-lock --force --yes"
       }));
@@ -74550,7 +74556,7 @@ async function run7(argv, io) {
   const dryRun = argv.includes("--dry-run");
   const pruneRecovery = argv.includes("--prune-recovery");
   if (pruneRecovery && !dryRun && !argv.includes("--yes"))
-    return emit(io, fail("blocked", "--prune-recovery deletes the 2.x recovery copies; confirm with --yes", {
+    return emit(io, fail2("blocked", "--prune-recovery deletes the 2.x recovery copies; confirm with --yes", {
       unblock: "workit gc --prune-recovery --yes"
     }));
   const store = new TaskStore(workspaceRootFor({ cwd: io.cwd }));
@@ -74558,11 +74564,11 @@ async function run7(argv, io) {
   const logs = location.ok ? pruneCheckLogs(location.data.dir, { dryRun }) : null;
   const result = store.collectGarbage({ dryRun, pruneRecovery });
   if (!result.ok)
-    return emit(io, fail(result.code === "busy" ? "busy" : "failed", `${result.code}: ${result.error}`, {
+    return emit(io, fail2(result.code === "busy" ? "busy" : "failed", `${result.code}: ${result.error}`, {
       data: { code: result.code, details: result.details },
       ...result.code === "busy" ? { unblock: "retry `workit gc`" } : {}
     }));
-  return emit(io, ok({ ...result.data, logs }), (data) => {
+  return emit(io, ok2({ ...result.data, logs }), (data) => {
     const verb = data.dryRun ? "would" : "did";
     const { compacted, blobs, legacyRecovery } = data;
     return [
@@ -74594,7 +74600,7 @@ __export(exports_uninstall, {
 });
 async function run8(_argv, io) {
   if (io.json)
-    return emit(io, fail("invalid_input", "workit uninstall is interactive and has no --json output", {
+    return emit(io, fail2("invalid_input", "workit uninstall is interactive and has no --json output", {
       unblock: "run `workit uninstall` in a terminal without --json"
     }));
   await init_src2();
@@ -74619,11 +74625,11 @@ function show(argv, io) {
   if (all || named.length === 1) {
     const listed = listGrants();
     if (listed.error)
-      return emit(io, fail("invalid_input", listed.error));
+      return emit(io, fail2("invalid_input", listed.error));
     const rows = named.length ? listed.workspaces.filter((entry) => entry.name === named[0]) : listed.workspaces;
     if (named.length && rows.length === 0)
-      return emit(io, fail("not_found", `no workspace named "${named[0]}" in ${listed.path}`));
-    return emit(io, ok({ path: listed.path, defaults: DEFAULT_GRANTS, workspaces: rows }), () => rows.flatMap((entry) => [
+      return emit(io, fail2("not_found", `no workspace named "${named[0]}" in ${listed.path}`));
+    return emit(io, ok2({ path: listed.path, defaults: DEFAULT_GRANTS, workspaces: rows }), () => rows.flatMap((entry) => [
       `${entry.name} (${entry.glob})`,
       ...describe2(entry.grants, entry.configured, entry, entry.verification)
     ]));
@@ -74632,7 +74638,7 @@ function show(argv, io) {
   try {
     autonomy = resolveAutonomy(io.cwd);
   } catch (error) {
-    return emit(io, fail("invalid_input", error instanceof Error ? error.message : String(error)));
+    return emit(io, fail2("invalid_input", error instanceof Error ? error.message : String(error)));
   }
   const tracks = releaseTracksReport(io.cwd);
   const tierModelIssues = workspaceTierModelIssues(io.cwd);
@@ -74641,7 +74647,7 @@ function show(argv, io) {
     ...tracks.tracks.length || tracks.error ? { releaseTracks: tracks } : {},
     ...tierModelIssues.length ? { tierModelIssues } : {}
   };
-  return emit(io, ok(shown), (data) => [
+  return emit(io, ok2(shown), (data) => [
     ...data.note ? [`note: ${data.note}`] : [],
     ...tierModelIssues.map((issue) => `note: ${issue}`),
     data.workspace ? `workspace ${data.workspace} (${data.source === "default" ? "D4 defaults" : `from ${data.source}`})` : "no workspace matches this checkout: D4 defaults apply",
@@ -74656,10 +74662,10 @@ async function change(verb, argv, io, deps) {
     return usage2(io, `${verb} needs <workspace> and a kind`);
   const listed = listGrants();
   if (listed.error)
-    return emit(io, fail("invalid_input", listed.error));
+    return emit(io, fail2("invalid_input", listed.error));
   const entry = listed.workspaces.find((item) => item.name === workspace);
   if (!entry)
-    return emit(io, fail("not_found", `no workspace named "${workspace}" in ${listed.path}`));
+    return emit(io, fail2("not_found", `no workspace named "${workspace}" in ${listed.path}`));
   const changes = [];
   let endpoint;
   let verification;
@@ -74703,17 +74709,17 @@ async function change(verb, argv, io, deps) {
     const command = `workit grant ${verb} ${workspace} ${specs.join(" ")}`;
     const agent = agentMarker(io.env);
     if (!deps.interactive() || agent)
-      return emit(io, fail("blocked", `grant_raise_refused: raising ${raised.map(({ kind }) => kind).join(", ")} needs the user at an interactive terminal${agent ? ` (this shell belongs to an agent: ${agent} is set)` : ""}; grants are never raised headless`, { unblock: `ask the user to run, in their own terminal: ${command}` }));
+      return emit(io, fail2("blocked", `grant_raise_refused: raising ${raised.map(({ kind }) => kind).join(", ")} needs the user at an interactive terminal${agent ? ` (this shell belongs to an agent: ${agent} is set)` : ""}; grants are never raised headless`, { unblock: `ask the user to run, in their own terminal: ${command}` }));
     const answer = await askOrCancel(io, () => deps.ask(`Raise ${raised.map(({ kind, value }) => `${kind}=${value}`).join(", ")} for workspace "${workspace}"? An agent there may then do this without asking. Type the workspace name to confirm: `));
     if (answer === null)
       return cancelled(io);
     if (answer.trim() !== workspace)
-      return emit(io, fail("blocked", "grant change not confirmed; nothing was written"));
+      return emit(io, fail2("blocked", "grant change not confirmed; nothing was written"));
   }
   const written = writeGrants(workspace, changes, undefined, endpoint, verification);
   if (!written.ok)
-    return emit(io, fail(written.code, written.error));
-  return emit(io, ok(written), (data) => [
+    return emit(io, fail2(written.code, written.error));
+  return emit(io, ok2(written), (data) => [
     `${data.workspace}: grants updated in ${data.path}${data.backup ? ` (previous copy: ${data.backup})` : ""}`,
     ...describe2(data.grants, data.configured, data, data.verification)
   ]);
@@ -74734,7 +74740,7 @@ var USAGE2 = "workit grant show [<workspace>] [--all] | grant set <workspace> <k
   `  default endpoint: ${endpointLabel(endpoint)} (an unnamed request stops at ${STOPS_AT[endpoint.effectiveEndpoint]})`,
   ...endpoint.endpointIssue ? [`  note: ${endpoint.endpointIssue}`] : [],
   `  verification: ${verification} (${verification === "independent" ? "a normal-risk behavior change needs a non-author verdict" : "a normal-risk behavior change needs a passing check and the author's --self verdict, shown as self-reviewed"})`
-], usage2 = (io, message) => emit(io, fail("invalid_input", `${message}
+], usage2 = (io, message) => emit(io, fail2("invalid_input", `${message}
 usage: ${USAGE2}`)), run9 = (argv, io) => runGrant(argv, io);
 var init_grant = __esm(() => {
   init_autonomy();
@@ -75851,7 +75857,7 @@ async function prepareHeavy(io, settings, label, runCwd, timeoutMs) {
   });
   if (!acquired.ok && acquired.reason === "timeout") {
     const holders = acquired.holders.map((holder) => describeHolder(holder)).join("; ");
-    emit(io, fail("busy", `the heavy-check lease stayed busy for ${Math.round(acquired.waitedMs / 1000)} s`, {
+    emit(io, fail2("busy", `the heavy-check lease stayed busy for ${Math.round(acquired.waitedMs / 1000)} s`, {
       data: { lease: { waitedMs: acquired.waitedMs, holders: acquired.holders } },
       unblock: `wait for ${holders || "the holders"} to finish, then run it again`
     }));
@@ -75901,7 +75907,7 @@ async function prepareHeavy(io, settings, label, runCwd, timeoutMs) {
 async function run10(argv, io) {
   const options = parse5(argv);
   if (options instanceof Error)
-    return emit(io, fail("invalid_input", options.message, { unblock: USAGE3 }));
+    return emit(io, fail2("invalid_input", options.message, { unblock: USAGE3 }));
   const config = loadCheckConfig(io.cwd);
   if (config.note)
     io.stderr(`note: ${config.note}
@@ -75912,13 +75918,13 @@ async function run10(argv, io) {
   let name = options.name;
   if (options.command === null) {
     if (options.positionals.length !== 1 || options.name || options.shell)
-      return emit(io, fail("invalid_input", "pass a check name, or a command after --", { unblock: USAGE3 }));
+      return emit(io, fail2("invalid_input", "pass a check name, or a command after --", { unblock: USAGE3 }));
     name = options.positionals[0];
     if (config.error)
-      return emit(io, fail("invalid_input", `check config is invalid: ${config.error}`));
+      return emit(io, fail2("invalid_input", `check config is invalid: ${config.error}`));
     const check = config.checks.find((item) => item.name === name);
     if (!check)
-      return emit(io, fail("not_found", `no configured check named "${name}"`, {
+      return emit(io, fail2("not_found", `no configured check named "${name}"`, {
         data: { configured: config.checks.map((item) => item.name), source: config.source },
         unblock: config.checks.length ? `workit check ${config.checks.map((item) => item.name).join("|")}` : `add {"checks":{"${name}":"<command>"}} to .workit/checks.json, or run workit check --name ${name} -- <cmd…>`
       }));
@@ -75926,14 +75932,14 @@ async function run10(argv, io) {
     runCwd = config.root;
   } else {
     if (options.positionals.length)
-      return emit(io, fail("invalid_input", `unexpected argument ${options.positionals[0]} before --`, {
+      return emit(io, fail2("invalid_input", `unexpected argument ${options.positionals[0]} before --`, {
         unblock: USAGE3
       }));
     command = options.command;
     if (!command.length)
-      return emit(io, fail("invalid_input", "no command after --", { unblock: USAGE3 }));
+      return emit(io, fail2("invalid_input", "no command after --", { unblock: USAGE3 }));
     if (options.shell && command.length !== 1)
-      return emit(io, fail("invalid_input", '--shell takes the command as one string: workit check --shell -- "<cmd>"'));
+      return emit(io, fail2("invalid_input", '--shell takes the command as one string: workit check --shell -- "<cmd>"'));
   }
   const relCwd = posix(path45.relative(top, runCwd));
   const configured = !options.shell && matchesNamedCheck(config, name, command, relCwd);
@@ -76146,7 +76152,7 @@ function slotLines(slots) {
 async function status(io) {
   const settings = await settingsFor(io);
   const slots = leaseSlots(leaseDir(io.env), settings.slots);
-  return emit(io, ok({ dir: leaseDir(io.env), slots, waitMs: settings.waitMs }), (data) => slotLines(data.slots));
+  return emit(io, ok2({ dir: leaseDir(io.env), slots, waitMs: settings.waitMs }), (data) => slotLines(data.slots));
 }
 function timeoutOf(args) {
   const at = args.findIndex((arg) => arg === "--timeout" || arg.startsWith("--timeout="));
@@ -76159,7 +76165,7 @@ function timeoutOf(args) {
 async function wait(args, io) {
   const timeout = timeoutOf(args);
   if (timeout instanceof Error)
-    return emit(io, fail("invalid_input", timeout.message));
+    return emit(io, fail2("invalid_input", timeout.message));
   const settings = await settingsFor(io);
   const limit = timeout ?? settings.waitMs;
   const dir = leaseDir(io.env);
@@ -76170,11 +76176,11 @@ async function wait(args, io) {
     const busy = held(slots);
     const waitedMs = Date.now() - started;
     if (busy.length < slots.length)
-      return emit(io, ok({ free: true, waitedMs, slots }), () => [
+      return emit(io, ok2({ free: true, waitedMs, slots }), () => [
         `workit: the heavy-check lease has a free slot${waitedMs ? ` after ${Math.round(waitedMs / 1000)} s` : ""}`
       ]);
     if (waitedMs >= limit)
-      return emit(io, fail("busy", `the heavy-check lease stayed busy for ${Math.round(waitedMs / 1000)} s`, {
+      return emit(io, fail2("busy", `the heavy-check lease stayed busy for ${Math.round(waitedMs / 1000)} s`, {
         data: { free: false, waitedMs, slots },
         unblock: "workit lock status"
       }));
@@ -76191,7 +76197,7 @@ async function runHeavy(args, io) {
   const head = split < 0 ? args : args.slice(0, split);
   const unknown = head.find((arg, index) => arg !== "--shell" && arg !== "--json" && !arg.startsWith("--timeout") && !arg.startsWith("--wait") && !((head[index - 1] === "--timeout" || head[index - 1] === "--wait") && !arg.startsWith("-")));
   if (split < 0 || unknown)
-    return emit(io, fail("invalid_input", unknown ? `unexpected ${unknown}` : "no command after --", {
+    return emit(io, fail2("invalid_input", unknown ? `unexpected ${unknown}` : "no command after --", {
       unblock: "workit lock run [--shell] [--wait <s>] [--timeout <s>] -- <cmd…>"
     }));
   const check = await Promise.resolve().then(() => (init_check(), {}));
@@ -76219,7 +76225,7 @@ async function heavy(args, io) {
   const [action, ...rest] = args.filter((arg) => arg !== "--json");
   const file = heavyCommandsFile(io.env);
   if (action === "list")
-    return emit(io, ok({ file, machine: machinePatterns(io.env), repo: repoPatterns(io.cwd) }), (data) => [
+    return emit(io, ok2({ file, machine: machinePatterns(io.env), repo: repoPatterns(io.cwd) }), (data) => [
       "built in: test runners, builds and bundlers, lint and typecheck, installs, image builds, Sonar, browser tests (JS, Go, Rust, JVM, .NET, Python, Ruby, PHP, Elixir, Swift, C)",
       `machine (${data.file}): ${data.machine.length ? data.machine.join(", ") : "none"}`,
       `repo (checks config resources.heavyCommands): ${data.repo.length ? data.repo.join(", ") : "none"}`
@@ -76227,7 +76233,7 @@ async function heavy(args, io) {
   if (action === "add" || action === "remove") {
     const pattern = commandText(rest);
     if (!parsePattern(pattern))
-      return emit(io, fail("invalid_input", `${action} needs a command pattern`, {
+      return emit(io, fail2("invalid_input", `${action} needs a command pattern`, {
         unblock: `workit lock heavy ${action} '<command words>'`
       }));
     const current = readPatterns(file);
@@ -76238,22 +76244,22 @@ async function heavy(args, io) {
       if (patterns !== current.patterns)
         writePatterns(file, { ...current, patterns });
     } catch (error) {
-      return emit(io, fail("unavailable", `cannot write ${file}: ${error.message}`));
+      return emit(io, fail2("unavailable", `cannot write ${file}: ${error.message}`));
     }
     const changed = action === "add" ? !has : has;
-    return emit(io, ok({ file, pattern: normalized, changed, patterns }), () => [
+    return emit(io, ok2({ file, pattern: normalized, changed, patterns }), () => [
       action === "add" ? `workit: ${changed ? "added" : "already had"} heavy pattern "${normalized}" (machine-wide, ${file})` : `workit: ${changed ? "removed" : "had no"} heavy pattern "${normalized}"`
     ]);
   }
   if (action === "test") {
     const command = commandText(rest);
     if (!command)
-      return emit(io, fail("invalid_input", "test needs a command", {
+      return emit(io, fail2("invalid_input", "test needs a command", {
         unblock: "workit lock heavy test -- <cmd…>"
       }));
     const match = heavyCommand(command, { cwd: io.cwd, env: io.env });
     const plan = heavyPlan(command, { cwd: io.cwd, env: io.env, rules: null });
-    return emit(io, ok({
+    return emit(io, ok2({
       command,
       heavy: Boolean(match),
       reason: match?.reason ?? null,
@@ -76262,7 +76268,7 @@ async function heavy(args, io) {
       split: plan.kind === "split" ? plan.reason : null
     }), (data) => !data.heavy ? ["light: the shell hook leaves it alone"] : data.rewrite ? [`heavy (${data.reason}): the shell hook runs it as ${data.rewrite}`] : data.split ? [`heavy (${data.reason}): the shell hook denies the chain: ${data.split}`] : [`heavy (${data.reason}): outside a git checkout the shell hook leaves it alone`]);
   }
-  return emit(io, fail("invalid_input", `unknown lock heavy action ${action ?? "(none)"}`, {
+  return emit(io, fail2("invalid_input", `unknown lock heavy action ${action ?? "(none)"}`, {
     unblock: "workit lock heavy list|add <pattern>|remove <pattern>|test -- <cmd…>"
   }));
 }
@@ -76276,7 +76282,7 @@ async function run11(argv, io) {
     return runHeavy(rest, io);
   if (sub === "heavy")
     return heavy(rest, io);
-  return emit(io, fail("invalid_input", `unknown lock subcommand ${sub ?? "(none)"}`, { unblock: USAGE4 }));
+  return emit(io, fail2("invalid_input", `unknown lock subcommand ${sub ?? "(none)"}`, { unblock: USAGE4 }));
 }
 var USAGE4 = "workit lock status | wait [--timeout <s>] | run [--shell] [--wait <s>] [--timeout <s>] -- <cmd…> | heavy list|add|remove|test", held = (slots) => slots.filter((slot) => slot.holder && !slot.stale), sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), commandText = (args) => {
   const split = args.indexOf("--");
@@ -76295,15 +76301,15 @@ async function logTimeUpdate(input, operation = defaultOperations) {
   try {
     const value = await operation.logTime(input);
     if (notApplied(value))
-      return fail2(value.error, {
+      return fail(value.error, {
         issueId: input.issueId,
         loggedMinutes: 0,
         outcome: "not_applied",
         retry: "youtrack.time"
       });
-    return ok2(unwrap(value));
+    return ok(unwrap(value));
   } catch (error) {
-    return fail2(message(error), {
+    return fail(message(error), {
       issueId: input.issueId,
       loggedMinutes: 0,
       outcome: "unknown",
@@ -82161,7 +82167,7 @@ function renderStatus(doc) {
   lines.push(`next: ${doc.next}`);
   return lines;
 }
-var forgeDeps, MAX_REASON = 500, usage3 = (io, message, line) => emit(io, fail("invalid_input", message, { unblock: line })), forgeFail = (io, result, data) => emit(io, fail(result.code, result.error, { data, unblock: result.unblock })), CONNECT_BUDGET_MS = 15000, pushIdentity = (io, branch) => checkPushIdentity(io.cwd, {
+var forgeDeps, MAX_REASON = 500, usage3 = (io, message, line) => emit(io, fail2("invalid_input", message, { unblock: line })), forgeFail = (io, result, data) => emit(io, fail2(result.code, result.error, { data, unblock: result.unblock })), CONNECT_BUDGET_MS = 15000, pushIdentity = (io, branch) => checkPushIdentity(io.cwd, {
   branch,
   env: io.env,
   runner: forgeDeps.runner,
@@ -82228,7 +82234,7 @@ async function status2(argv, io) {
   const doc = report.data.doc;
   const hint = nextHint(doc.next, doc.number);
   const issues = issuesBlock(io.cwd, doc);
-  return emit(io, ok({ ...doc, nextHint: hint, verdict: verdictBlock(io.cwd, doc.head.branch, doc), issues }), (data) => {
+  return emit(io, ok2({ ...doc, nextHint: hint, verdict: verdictBlock(io.cwd, doc.head.branch, doc), issues }), (data) => {
     const lines = renderStatus(data);
     if (data.issues?.length)
       lines.splice(1, 0, `issues: ${data.issues.map((entry) => `${entry.tracker === "youtrack" ? entry.issue : entry.url ?? `${entry.repo ?? ""}#${entry.issue}`} (${entry.relation})`).join(", ")}`);
@@ -82312,18 +82318,18 @@ async function create4(argv, io) {
     const flow = gitFlowOf(io.cwd);
     const mismatch = flowMismatch(flow, kind, base, "target");
     if (mismatch && flow && kind)
-      return emit(io, fail("blocked", mismatch, {
+      return emit(io, fail2("blocked", mismatch, {
         unblock: `workit pr create …  # without --base it targets ${flowRoute(flow, kind).target}`
       }));
   } else {
     const resolved = vcsConfig("resolve", io.cwd, { track: flags.values.track ?? null });
     if (resolved.ok === false)
-      return emit(io, fail("blocked", String(resolved.error), {
+      return emit(io, fail2("blocked", String(resolved.error), {
         unblock: "fix ~/.config/workit/vcs.json or pass --base <b>"
       }));
     releaseTrack = resolved.releaseTrack ?? null;
     if (releaseTrack?.blocking)
-      return emit(io, fail("blocked", releaseTrack.blocking, {
+      return emit(io, fail2("blocked", releaseTrack.blocking, {
         unblock: "workit pr create --track <name> …  # or --base <branch>"
       }));
     base = String(resolved.defaultTargetBranch ?? "") || null;
@@ -82385,7 +82391,7 @@ async function create4(argv, io) {
     ...releaseTrack ? { releaseTrack } : {},
     ...route ? { flow: route } : {}
   };
-  return emit(io, ok(created), (data) => [
+  return emit(io, ok2(created), (data) => [
     `${data.created ? "opened" : "found open"} ${connected.data.forge.kind === "github" ? "PR #" : "MR !"}${data.number}${data.draft && data.created ? " (draft)" : ""}: ${data.branch} -> ${data.base}  ${data.url}`,
     ...data.releaseTrack?.name ? [`release track: ${data.releaseTrack.name} (${data.releaseTrack.detail})`] : [],
     ...(data.releaseTrack?.warnings ?? []).map((warning) => `note: ${warning}`),
@@ -82465,11 +82471,11 @@ async function merge3(argv, io) {
     ...body !== undefined ? { body } : {}
   }, forgeDeps.sleep);
   if (!result.ok)
-    return emit(io, fail(result.code, result.error, {
+    return emit(io, fail2(result.code, result.error, {
       unblock: result.unblock,
       data: "refusal" in result && result.refusal ? result.refusal : ("recorded" in result) && result.recorded ? { recorded: result.recorded } : {}
     }));
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `merged ${connected.data.forge.kind === "github" ? "PR #" : "MR !"}${data.number} (${data.method}) at head ${data.head.slice(0, 12)}${data.mergeSha ? ` -> ${data.mergeSha.slice(0, 12)}` : ""}`,
     data.unverified ? `UNVERIFIED: merged without a verdict (--unverified: ${data.unverified.reason}); ledger ${data.unverified.recorded}` : `verdict ${data.verdict.verdictId ?? "?"} accepted for that head`,
     ...data.mergeBack.length ? [
@@ -82499,7 +82505,7 @@ async function ready(argv, io) {
   if (!result.ok)
     return forgeFail(io, result);
   const kind = connected.data.forge.kind;
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `${prLabel(kind, data.number)} ${data.changed ? "is now" : "was already"} ${data.draft ? "a draft" : "ready for review"}  ${data.url}`
   ]);
 }
@@ -82544,7 +82550,7 @@ async function edit(argv, io) {
   if (!result.ok)
     return result.code === "invalid_input" ? usage3(io, result.error, EDIT_USAGE) : forgeFail(io, result);
   const kind = connected.data.forge.kind;
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `edited ${prLabel(kind, data.number)} (${data.changed.join(", ")}): ${data.title} -> ${data.base}  ${data.url}`
   ]);
 }
@@ -82564,7 +82570,7 @@ async function threads(argv, io) {
   if (!result.ok)
     return forgeFail(io, result);
   const kind = connected.data.forge.kind;
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `${prLabel(kind, data.number)}: ${data.threads.length} unresolved thread${data.threads.length === 1 ? "" : "s"}${data.truncated ? " (truncated at the page cap)" : ""}`,
     ...data.threads.map((thread) => `${thread.id}  ${thread.path ? `${thread.path}${thread.line ? `:${thread.line}` : ""} ` : ""}@${thread.author ?? "?"}${thread.isBot ? " (bot)" : ""}${thread.outdated ? " (outdated)" : ""}: ${thread.body}`)
   ]);
@@ -82605,7 +82611,7 @@ async function reply(argv, io) {
   if (!result.ok)
     return result.code === "invalid_input" ? usage3(io, result.error, REPLY_USAGE) : forgeFail(io, result);
   const kind = connected.data.forge.kind;
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `${[data.replied ? "replied to" : null, data.resolved ? "resolved" : null].filter(Boolean).join(" and ")} thread ${data.thread} on ${prLabel(kind, data.number)}${data.replyUrl ? `  ${data.replyUrl}` : ""}`
   ]);
 }
@@ -82717,7 +82723,7 @@ async function wait2(argv, io) {
   }
   const elapsedMs = forgeDeps.now() - started;
   if (!status)
-    return emit(io, fail("unavailable", "no successful poll before the timeout", { data: { polls } }));
+    return emit(io, fail2("unavailable", "no successful poll before the timeout", { data: { polls } }));
   const left = deadline - forgeDeps.now();
   const built = buildStatusDoc(io.cwd, resolved, status, {
     logLines: verdict.state === "failed" && left > 0 ? 60 : 0,
@@ -82741,18 +82747,18 @@ async function wait2(argv, io) {
       io.stdout(`${value}
 `);
   if (verdict.state === "ready")
-    return emit(io, ok(data), () => [
+    return emit(io, ok2(data), () => [
       `CI ready (${verdict.reason}) after ${polls} poll${polls === 1 ? "" : "s"}, ${seconds(elapsedMs)}`,
       ...renderStatus(doc)
     ]);
   if (verdict.state === "failed")
-    return emit(io, fail("failed", `CI failed: ${doc.checks.failing.map((check) => check.name).join(", ")}`, {
+    return emit(io, fail2("failed", `CI failed: ${doc.checks.failing.map((check) => check.name).join(", ")}`, {
       data,
       unblock: "fix the failure, or if it is a flake: workit ci rerun --failed --reason flake"
     }));
   if (verdict.state === "blocked")
-    return emit(io, fail("blocked", `CI wait blocked: ${verdict.reason}`, { data, unblock: verdict.unblock }));
-  return emit(io, fail("pending", `CI still ${verdict.reason.replaceAll("_", " ")} after ${seconds(elapsedMs)}`, {
+    return emit(io, fail2("blocked", `CI wait blocked: ${verdict.reason}`, { data, unblock: verdict.unblock }));
+  return emit(io, fail2("pending", `CI still ${verdict.reason.replaceAll("_", " ")} after ${seconds(elapsedMs)}`, {
     data,
     unblock: `workit ci wait --pr ${doc.number}${head ? ` --head ${head}` : ""}`
   }));
@@ -82786,12 +82792,12 @@ async function rerun(argv, io) {
     return forgeFail(io, connected);
   const resolved = connected.data;
   if (resolved.expectedAccount && resolved.identity.login === null)
-    return emit(io, fail("blocked", `identity_unverified: the credential cannot prove it is ${resolved.expectedAccount} (${resolved.identity.note ?? "no /user access"})`, {
+    return emit(io, fail2("blocked", `identity_unverified: the credential cannot prove it is ${resolved.expectedAccount} (${resolved.identity.note ?? "no /user access"})`, {
       unblock: `use a credential for ${resolved.expectedAccount} that can read /user (vcs.tokenFile or ${resolved.forge.kind === "github" ? "gh" : "glab"} auth login --hostname ${resolved.forge.apiHost})`
     }));
   const grant = requireGrant(io.cwd, "rerun");
   if (!grant.allowed)
-    return emit(io, fail("blocked", grant.error, { unblock: grant.unblock, data: { reason: grant.reason } }));
+    return emit(io, fail2("blocked", grant.error, { unblock: grant.unblock, data: { reason: grant.reason } }));
   const number = selectPr(io.cwd, resolved, { pr, branch: flags.values.branch ?? null });
   if (!number.ok)
     return forgeFail(io, number);
@@ -82807,7 +82813,7 @@ async function rerun(argv, io) {
   if (!done.ok)
     return forgeFail(io, done);
   const outcome = done.data;
-  return emit(io, ok(outcome), () => [
+  return emit(io, ok2(outcome), () => [
     `rerun requested on #${outcome.pr} head ${outcome.head.slice(0, 7)} (${outcome.reason}${outcome.forced ? ", forced" : ""}): ${outcome.rerun.map((check) => check.name).join(", ")}`,
     ...outcome.skipped.length ? [`not rerunnable here: ${outcome.skipped.join(", ")}`] : [],
     ...outcome.recorded ? [] : ["warning: the rerun could not be recorded; the once-per-head guard will not see it"],
@@ -82906,7 +82912,7 @@ async function branch(argv, io) {
   });
   if (!result.ok)
     return forgeFail(io, result);
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `switched to new branch ${data.branch} from ${data.baseRef} (${short2(data.baseSha)})${data.carried ? ", carrying uncommitted changes" : ""}`,
     ...data.releaseTrack?.name ? [`release track: ${data.releaseTrack.name} (${data.releaseTrack.detail})`] : [],
     ...data.notes.map((note) => `note: ${note}`)
@@ -83007,7 +83013,7 @@ async function commit(argv, io) {
   if (!result.ok)
     return forgeFail(io, result);
   await ensureImplicitTask(io);
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `${data.branch} ${short2(data.sha)} ${data.message.split(`
 `, 1)[0]} (${data.files.length ? `${data.files.length} file${data.files.length === 1 ? "" : "s"}` : "empty commit"})${data.amended ? `, amends ${short2(data.amended)}` : ""}`,
     ...data.leftDirty ? [`${data.leftDirty} change(s) left uncommitted`] : [],
@@ -83051,7 +83057,7 @@ async function push(argv, io) {
   const checked = identity?.data ?? null;
   const grant = requireGrant(io.cwd, "push", { forge: checked?.forge != null });
   if (!grant.allowed)
-    return emit(io, fail("blocked", grant.error, {
+    return emit(io, fail2("blocked", grant.error, {
       unblock: grant.unblock,
       data: { reason: grant.reason }
     }));
@@ -83074,7 +83080,7 @@ async function push(argv, io) {
   for (const warning of warnings)
     io.stderr(`warning: ${warning}
 `);
-  const envelope = ok({ ...result.data, identity: checked });
+  const envelope = ok2({ ...result.data, identity: checked });
   return emit(io, warnings.length ? { ...envelope, warnings } : envelope, (data) => [
     data.pushed ? `pushed ${data.branch} ${short2(data.previous)} -> ${short2(data.sha)} to ${data.remote}${data.forced ? " (force-with-lease)" : ""}; remote tip verified` : `${data.remote}/${data.branch} is already at ${short2(data.sha)}; remote tip verified`,
     ...data.upstream ? [`upstream: ${data.remote}/${data.branch}`] : []
@@ -83086,7 +83092,7 @@ async function releasePush(names, io) {
     return forgeFail(io, plan);
   const release = requireGrant(io.cwd, "release");
   if (!release.allowed)
-    return emit(io, fail("blocked", release.error, {
+    return emit(io, fail2("blocked", release.error, {
       unblock: release.unblock,
       data: { reason: release.reason }
     }));
@@ -83097,7 +83103,7 @@ async function releasePush(names, io) {
   const checked = identity?.data ?? null;
   const pushGrant = requireGrant(io.cwd, "push", { forge: checked?.forge != null });
   if (!pushGrant.allowed)
-    return emit(io, fail("blocked", pushGrant.error, {
+    return emit(io, fail2("blocked", pushGrant.error, {
       unblock: pushGrant.unblock,
       data: { reason: pushGrant.reason }
     }));
@@ -83108,7 +83114,7 @@ async function releasePush(names, io) {
   });
   if (!result.ok)
     return forgeFail(io, result);
-  return emit(io, ok({ ...result.data, identity: checked }), (data) => [
+  return emit(io, ok2({ ...result.data, identity: checked }), (data) => [
     ...data.refs.map((ref) => ref.pushed ? `pushed ${ref.name} ${short2(ref.previous)} -> ${short2(ref.sha)} to ${data.remote}; remote tip verified` : `${data.remote} ${ref.name} is already at ${short2(ref.sha)}; remote tip verified`),
     ..."error" in data.recorded ? [`ledger: not recorded (${data.recorded.error})`] : []
   ]);
@@ -83118,7 +83124,7 @@ function trailers(argv, io) {
   if (extra !== undefined)
     return usage3(io, `unexpected argument ${extra}`, "workit git trailers");
   const state = workspaceTrailers(io.cwd);
-  return emit(io, ok(state), (data) => data.enabled ? "on" : "off");
+  return emit(io, ok2(state), (data) => data.enabled ? "on" : "off");
 }
 async function run14(argv, io) {
   const [sub, ...rest] = argv;
@@ -83828,7 +83834,7 @@ async function subVerb(load, argv, io) {
   try {
     return JSON.parse(out);
   } catch {
-    return fail("failed", (out + err).trim() || `${argv.join(" ")} printed nothing`);
+    return fail2("failed", (out + err).trim() || `${argv.join(" ")} printed nothing`);
   }
 }
 async function start(argv, io) {
@@ -83845,7 +83851,7 @@ async function start(argv, io) {
   });
   if (!result.ok)
     return forgeFail(io, result);
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `started ${data.branch} from ${data.base} (${short4(data.baseSha)}), local only; it will be tagged ${data.tag}`,
     `next: commit the version bump, changelog and docs on ${data.branch} (workit git commit), then: workit release finish`,
     ...data.notes.map((note) => `note: ${note}`)
@@ -83854,7 +83860,7 @@ async function start(argv, io) {
 async function releasePr(io, plan, dryRun) {
   const title = `chore(release): ${plan.version}`;
   if (dryRun)
-    return emit(io, ok({
+    return emit(io, ok2({
       ...plan,
       steps: [`push ${plan.branch}`, `open a PR ${plan.branch} -> ${plan.production}: ${title}`]
     }), () => [
@@ -83881,7 +83887,7 @@ async function releasePr(io, plan, dryRun) {
     branch: plan.branch,
     pr: pr.data.number ?? null
   });
-  return emit(io, ok({ ...plan, pr: pr.data }), () => [
+  return emit(io, ok2({ ...plan, pr: pr.data }), () => [
     `opened the release PR ${String(pr.data.url ?? "")} into ${plan.production}`,
     `next: once it merges, tag the merged commit ${plan.tag} and: workit git push --release ${plan.tag}`
   ]);
@@ -83902,7 +83908,7 @@ async function finish2(argv, io) {
   const plan = planned.data;
   if (!plan.gitflow) {
     if (!dryRun && plan.state.branchDeleted)
-      return emit(io, fail("not_found", `${plan.branch} is gone; nothing to open a PR from`));
+      return emit(io, fail2("not_found", `${plan.branch} is gone; nothing to open a PR from`));
     return releasePr(io, plan, dryRun);
   }
   const actor = actorFromEnv(io.env);
@@ -83918,8 +83924,8 @@ async function finish2(argv, io) {
     const missing = [release, push].find((grant) => !grant.allowed);
     const data = { ...plan, steps, grants: { release: release.allowed, push: push.allowed } };
     if (missing && !missing.allowed)
-      return emit(io, warned(fail("blocked", missing.error, { unblock: missing.unblock, data })));
-    return emit(io, warned(ok(data)), () => [
+      return emit(io, warned(fail2("blocked", missing.error, { unblock: missing.unblock, data })));
+    return emit(io, warned(ok2(data)), () => [
       `finish ${plan.branch} -> ${plan.production} as ${plan.tag}:`,
       ...steps.map((entry) => `  ${entry.done ? "done" : "todo"}  ${entry.step}`)
     ]);
@@ -83980,7 +83986,7 @@ async function finish2(argv, io) {
   if (!verified.ok)
     return forgeFail(io, verified, { step: "verify", resume });
   if (!verified.data.delivered)
-    return emit(io, fail("failed", `release_unverified: ${plan.tag} is not on ${plan.remote ?? "the remote"}`, {
+    return emit(io, fail2("failed", `release_unverified: ${plan.tag} is not on ${plan.remote ?? "the remote"}`, {
       data: { step: "verify", resume, report: verified.data },
       unblock: resume
     }));
@@ -83989,7 +83995,7 @@ async function finish2(argv, io) {
     branch: plan.branch,
     head: merged.data.tagTarget
   });
-  return emit(io, warned(ok({ ...plan, ran: merged.data.ran, push: pushed.data, forgeRelease, notes })), () => [
+  return emit(io, warned(ok2({ ...plan, ran: merged.data.ran, push: pushed.data, forgeRelease, notes })), () => [
     `finished ${plan.branch}: ${plan.production} and ${plan.mergeBack.join(", ")} merged, ${plan.tag} tagged on ${short4(merged.data.tagTarget)}`,
     `pushed ${[...plan.pushBranches, plan.tag].join(", ")} to ${plan.remote ?? "the remote"}; remote tips verified`,
     ...forgeRelease ? [
@@ -84032,7 +84038,7 @@ async function publish(argv, io) {
     branch: located.data.branch,
     head: result.data.sha
   });
-  return emit(io, ok({ ...result.data, version: located.data.version }), (data) => [
+  return emit(io, ok2({ ...result.data, version: located.data.version }), (data) => [
     `published ${data.branch} (${short4(data.sha)}) to ${data.remote}; remote tip verified`
   ]);
 }
@@ -84046,7 +84052,7 @@ async function run15(argv, io) {
     return publish(rest, io);
   return usage3(io, sub && !sub.startsWith("-") ? `unknown release subcommand "${sub}"` : "missing release subcommand", USAGE7);
 }
-var START_USAGE = "workit release start <version> [--hotfix] [--track <t>] [--json]", FINISH_USAGE = "workit release finish [<version>] [--track <t>] [--dry-run] [--json]", PUBLISH_USAGE = "workit release publish [<version>] [--json]", USAGE7 = "workit release start|finish|publish ... (workit help release)", short4 = (sha) => sha ? sha.slice(0, 12) : "(none)", blocked = (io, grant) => emit(io, fail("blocked", grant.error, { unblock: grant.unblock, data: { reason: grant.reason } })), isLocalRemote = (cwd, remote) => {
+var START_USAGE = "workit release start <version> [--hotfix] [--track <t>] [--json]", FINISH_USAGE = "workit release finish [<version>] [--track <t>] [--dry-run] [--json]", PUBLISH_USAGE = "workit release publish [<version>] [--json]", USAGE7 = "workit release start|finish|publish ... (workit help release)", short4 = (sha) => sha ? sha.slice(0, 12) : "(none)", blocked = (io, grant) => emit(io, fail2("blocked", grant.error, { unblock: grant.unblock, data: { reason: grant.reason } })), isLocalRemote = (cwd, remote) => {
   const url = remote ? pushUrl(cwd, remote) : null;
   return !url || parseRemoteUrl(url)?.protocol === "file";
 }, stepsOf = (plan) => [
@@ -84128,13 +84134,13 @@ async function run16(argv, io) {
     return forgeFail(io, result);
   const report = result.data;
   if (report.delivered)
-    return emit(io, ok(report), render2);
+    return emit(io, ok2(report), render2);
   const failed = report.observations.filter((entry) => !entry.ok);
   if (!io.json)
     for (const line of render2(report))
       io.stdout(`${line}
 `);
-  return emit(io, fail("failed", `not_delivered: ${failed.map((entry) => entry.note ?? `${entry.kind} is ${entry.observed ?? "absent"}, expected ${entry.expected ?? "-"}`).join("; ")}`, {
+  return emit(io, fail2("failed", `not_delivered: ${failed.map((entry) => entry.note ?? `${entry.kind} is ${entry.observed ?? "absent"}, expected ${entry.expected ?? "-"}`).join("; ")}`, {
     data: report,
     unblock: expect === "pushed" ? "workit git push" : expect === "pr" ? "workit git push && workit pr create --fill" : expect === "merged" ? "workit pr status  # then workit pr merge when READY and granted" : "check the release workflow; the tag/package is not published"
   }));
@@ -84185,11 +84191,11 @@ async function plan(argv, io) {
   if (trunk === null || track !== null) {
     const derived = releaseTrunk(io, track, flags.positionals[0] ?? null);
     if ("error" in derived)
-      return emit(io, fail("blocked", derived.error, {
+      return emit(io, fail2("blocked", derived.error, {
         unblock: "workit stack plan --track <name> …  # or --trunk <branch>"
       }));
     if (existing && track !== null && derived.trunk !== existing.trunk)
-      return emit(io, fail("invalid_input", `stack ${existing.name} is on trunk ${existing.trunk}; --track ${track} targets ${derived.trunk ?? "(none)"}`, { unblock: "drop --track to re-plan on the recorded trunk" }));
+      return emit(io, fail2("invalid_input", `stack ${existing.name} is on trunk ${existing.trunk}; --track ${track} targets ${derived.trunk ?? "(none)"}`, { unblock: "drop --track to re-plan on the recorded trunk" }));
     trunk ??= derived.trunk ?? "main";
   }
   const connected = connect(io, flags.positionals[0] ?? null);
@@ -84205,7 +84211,7 @@ async function plan(argv, io) {
   });
   if (!result.ok)
     return stackFailed(io, result);
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `${data.created ? "planned" : "re-planned"} stack ${data.stack.name} on ${data.stack.trunk}:`,
     ...data.stack.branches.map((entry, index) => {
       const check = data.checks.find((item) => item.branch === entry.branch);
@@ -84229,7 +84235,7 @@ async function status3(argv, io) {
   const result = stackStatus({ cwd: io.cwd, resolved: connected.data, actor: actorFromEnv(io.env), sleep: forgeDeps.sleep }, selected.data);
   if (!result.ok)
     return stackFailed(io, result);
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `stack ${data.name} on ${data.trunk}: ${data.verdict}${data.reason ? ` (${data.reason})` : ""}`,
     ...data.branches.map((row, index) => `  ${index + 1}. ${row.branch} ${label3(connected.data.forge.kind, row.pr)} ${row.merged ? "merged" : `${row.next ?? "?"} · checks ${row.checks ?? "?"} · verdict ${row.verdict.accepted ? `accepted (${row.verdict.basis})` : `missing (${row.verdict.reasons.join(", ") || row.verdict.basis})`} · ${row.onParent === false ? `not on ${row.parent}` : `on ${row.parent}`}${row.baseMatches === false ? ` · PR base ${row.prBase}` : ""}`}`),
     ...data.next ? [`next: ${data.next}`] : []
@@ -84279,7 +84285,7 @@ async function sync(argv, io) {
   });
   if (!result.ok)
     return stackFailed(io, result);
-  return emit(io, ok(result.data), renderSync);
+  return emit(io, ok2(result.data), renderSync);
 }
 async function land(argv, io) {
   const flags = parseFlags(argv, {
@@ -84332,7 +84338,7 @@ async function land(argv, io) {
   if (!result.ok)
     return stackFailed(io, result);
   const kind = connected.data.forge.kind;
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     ...data.dryRun ? [
       data.wouldLand.length ? `would land: ${data.wouldLand.map((item) => `${label3(kind, item.pr)} (${item.branch})`).join(", ")}` : "would land nothing"
     ] : [
@@ -84356,7 +84362,7 @@ async function run17(argv, io) {
     return land(rest, io);
   return usage3(io, sub && !sub.startsWith("-") ? `unknown stack subcommand "${sub}"` : "missing stack subcommand", USAGE9);
 }
-var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--timeout 20m] [--interval 30s] [--json]", USAGE9 = "workit stack plan|status|sync|land ... (workit help stack)", short5 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), label3 = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
+var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--timeout 20m] [--interval 30s] [--json]", USAGE9 = "workit stack plan|status|sync|land ... (workit help stack)", short5 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail2(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), label3 = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
   `${data.dryRun ? "would sync" : "synced"} stack ${data.name}${data.merged.length ? `; merged: ${data.merged.map((item) => item.branch).join(", ")}` : ""}`,
   ...data.steps.map((step) => [
     `  ${step.branch} on ${step.parent}:`,
@@ -85597,7 +85603,7 @@ function resolveTrunk(io, raw, flag, track) {
   const derived = releaseTrunk(io, track, null);
   if ("error" in derived)
     return {
-      code: emit(io, fail("blocked", derived.error, {
+      code: emit(io, fail2("blocked", derived.error, {
         unblock: "workit fanout plan <plan.json> --track <name>  # or --trunk <branch>"
       }))
     };
@@ -85643,7 +85649,7 @@ function plan2(argv, io) {
     renderBlockedPlan(io, result);
     return code;
   }
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     `${data.created ? "planned" : "re-planned"} fanout ${data.name} on ${data.trunk}${data.fanIn === "integration" ? " (integration branch: one PR)" : ""}: ${data.slices.length} slice${data.slices.length === 1 ? "" : "s"}`,
     ...data.slices.map((slice) => `  ${slice.id} [${slice.tier}] ${slice.branch} <- ${slice.base}${slice.dependsOn.length ? `  after ${slice.dependsOn.join(", ")}` : ""}
       worktree ${slice.worktree}`),
@@ -85678,7 +85684,7 @@ function brief(argv, io) {
   });
   if (!result.ok)
     return failed(io, result);
-  return emit(io, ok(result.data), (data) => data.text.trimEnd());
+  return emit(io, ok2(result.data), (data) => data.text.trimEnd());
 }
 function check2(argv, io) {
   const flags = parseFlags(argv, { name: "value", base: "value", offline: "boolean" });
@@ -85695,13 +85701,13 @@ function check2(argv, io) {
   if (!result.ok)
     return failed(io, result);
   if (result.data.ready)
-    return emit(io, ok(result.data), renderCheck);
+    return emit(io, ok2(result.data), renderCheck);
   if (!io.json)
     for (const line of renderCheck(result.data))
       io.stdout(`${line}
 `);
   const first = result.data.slices.find((slice) => slice.status === "blocked");
-  return emit(io, fail("blocked", `slice ${first?.id ?? "?"} is not ready: ${first?.reasons[0] ?? "blocked"}`, {
+  return emit(io, fail2("blocked", `slice ${first?.id ?? "?"} is not ready: ${first?.reasons[0] ?? "blocked"}`, {
     data: result.data,
     unblock: result.data.next
   }));
@@ -85727,7 +85733,7 @@ function status4(argv, io) {
   });
   if (!result.ok)
     return failed(io, result);
-  return emit(io, ok(result.data), renderStatus2);
+  return emit(io, ok2(result.data), renderStatus2);
 }
 function worktree(argv, io) {
   const [action, ...rest] = argv;
@@ -85751,7 +85757,7 @@ function worktree(argv, io) {
     });
     if (!result.ok)
       return failed(io, result);
-    return emit(io, ok(result.data), (data) => [
+    return emit(io, ok2(result.data), (data) => [
       `${data.created ? "created" : "kept"} worktree for slice ${data.slice} (${data.mode}): ${data.path}`,
       `  branch ${data.branch} <- ${data.base} at ${short6(data.head)}`,
       `  scratch ${data.scratch}  (put it in the worker brief: temp files go here)`,
@@ -85772,7 +85778,7 @@ function worktree(argv, io) {
 `);
     return code;
   }
-  return emit(io, ok(result.data), (data) => [
+  return emit(io, ok2(result.data), (data) => [
     data.removed ? `released slice ${data.slice}: removed ${data.path}${data.dirty.length ? ` (dropped ${data.dirty.length} uncommitted change${data.dirty.length === 1 ? "" : "s"}, recorded in the ledger)` : ""}; branch ${data.branch} kept` : `slice ${data.slice}: nothing released`,
     ...data.notes.map((note) => `note: ${note}`)
   ]);
@@ -85791,7 +85797,7 @@ async function run18(argv, io) {
     return worktree(rest, io);
   return usage3(io, sub && !sub.startsWith("-") ? `unknown fanout subcommand "${sub}"` : "missing fanout subcommand", USAGE10);
 }
-var PLAN_USAGE2 = "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] [--take-lead] [--json]", BRIEF_USAGE = "workit fanout brief <slice> [--name <n>] [--mode new|resume] [--attempt <n>] [--json]", CHECK_USAGE = "workit fanout check [<slice>…] [--name <n>] [--base <ref>] [--offline] [--json]", STATUS_USAGE3 = "workit fanout status [--name <n>] [--stuck-after 30m] [--offline] [--json]", WORKTREE_USAGE = "workit fanout worktree create <slice> [--name <n>] | worktree release <slice> [--name <n>] [--force] [--json]", USAGE10 = "workit fanout plan|brief|check|status|worktree ... (workit help fanout)", failed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), renderCheck = (data) => [
+var PLAN_USAGE2 = "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] [--take-lead] [--json]", BRIEF_USAGE = "workit fanout brief <slice> [--name <n>] [--mode new|resume] [--attempt <n>] [--json]", CHECK_USAGE = "workit fanout check [<slice>…] [--name <n>] [--base <ref>] [--offline] [--json]", STATUS_USAGE3 = "workit fanout status [--name <n>] [--stuck-after 30m] [--offline] [--json]", WORKTREE_USAGE = "workit fanout worktree create <slice> [--name <n>] | worktree release <slice> [--name <n>] [--force] [--json]", USAGE10 = "workit fanout plan|brief|check|status|worktree ... (workit help fanout)", failed = (io, result) => emit(io, fail2(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), renderCheck = (data) => [
   `fanout ${data.name} against ${data.trunkRef}: ${data.ready ? "ready to land" : "blocked"}`,
   ...data.slices.map((slice) => slice.status === "landed" ? `  -- ${slice.id} (${slice.branch}) landed (${slice.landed?.how}${slice.landed?.pr ? ` #${slice.landed.pr}` : ""})` : `  ${slice.status === "ready" ? "ok " : "x  "}${slice.id} (${slice.branch}) ${slice.changed} file${slice.changed === 1 ? "" : "s"} · verdict ${slice.verdict.accepted ? "accepted" : slice.verdict.basis}${slice.reasons.length ? `
       ${slice.reasons.join(`
@@ -85914,7 +85920,7 @@ async function run19(argv, io) {
     if (rest.length)
       return usage4(io, `unexpected argument: ${rest[0]}`);
     const integrity = ledger.value.integrity ?? { chained: 0, legacy: 0, unverified: [] };
-    return emit(io, ok({
+    return emit(io, ok2({
       path: ledger.value.path,
       intact: integrity.unverified.length === 0,
       chained: integrity.chained,
@@ -85931,7 +85937,7 @@ async function run19(argv, io) {
       type: values.type,
       last: last ?? 50
     });
-    return emit(io, ok({ path: ledger.value.path, skipped: ledger.value.skipped, rows: listed }), (data) => data.rows.length ? data.rows.map((row) => {
+    return emit(io, ok2({ path: ledger.value.path, skipped: ledger.value.skipped, rows: listed }), (data) => data.rows.length ? data.rows.map((row) => {
       const line = summarizeRow(row);
       return `#${line.seq} ${line.at} ${line.type}${line.branch ? ` [${line.branch}]` : ""}${line.labels.length ? ` (${line.labels.join(", ")})` : ""}  ${line.summary}`;
     }) : "ledger is empty");
@@ -85945,14 +85951,22 @@ async function run19(argv, io) {
       return failed2(io, target);
     const branch = target.value ?? currentBranch(io.cwd);
     if (!branch)
-      return emit(io, fail("invalid_input", "HEAD is detached; name the branch", {
+      return emit(io, fail2("invalid_input", "HEAD is detached; name the branch", {
         unblock: "pass --branch <branch>"
       }));
-    return emit(io, ok(checkVerdicts(io.cwd, branch, rows)), verdictLines);
+    return emit(io, ok2(checkVerdicts(io.cwd, branch, rows)), verdictLines);
   }
   const target = targetBranch(io, rows, values.branch, pr);
   if (!target.ok)
     return failed2(io, target);
+  if (values.head !== undefined) {
+    const actual = target.value === null ? headSha(io.cwd) : resolveRef(io.cwd, target.value);
+    const wanted = values.head.trim().toLowerCase();
+    if (!actual || wanted.length < 4 || !actual.startsWith(wanted))
+      return emit(io, fail2("invalid_input", `--head ${values.head} is not the head of ${target.value ?? "this checkout"}${actual ? ` (${actual.slice(0, 12)})` : ""}`, {
+        unblock: "a verdict is keyed to the branch head: check out the commit to judge (or pass --branch/--pr), or drop --head"
+      }));
+  }
   const acting = actorFor(io, values);
   if (acting instanceof Error)
     return usage4(io, acting.message);
@@ -85992,7 +86006,7 @@ async function run19(argv, io) {
   const token = values.token ?? io.env.WORKIT_SESSION_TOKEN ?? null;
   const refusal = claimed === null ? null : sessionClaimRefusal(io.env, claimed, io.cwd, { token, flag: acting.source === "flag" });
   if (refusal)
-    return emit(io, fail("blocked", refusal.error, { unblock: refusal.unblock }));
+    return emit(io, fail2("blocked", refusal.error, { unblock: refusal.unblock }));
   const bound = claimed !== null && issuedTokenMatches(io.cwd, claimed, token);
   const verdict = await recorded(recordVerdict({ ...context, ...bound ? { sessionBound: true } : {} }, {
     result: rest[0],
@@ -86031,10 +86045,10 @@ function standingFanout(io, values) {
 async function standing(io, values, args) {
   const [action, ...rest] = args;
   if (action !== "add" && action !== "list" && action !== "clear")
-    return emit(io, fail("invalid_input", action ? `unknown standing action "${action}"` : "missing add, list or clear", { unblock: STANDING_USAGE }));
+    return emit(io, fail2("invalid_input", action ? `unknown standing action "${action}"` : "missing add, list or clear", { unblock: STANDING_USAGE }));
   const target = standingFanout(io, values);
   if (target instanceof Error)
-    return emit(io, fail("invalid_input", target.message, { unblock: STANDING_USAGE }));
+    return emit(io, fail2("invalid_input", target.message, { unblock: STANDING_USAGE }));
   const fanout = target.name;
   const lead = target.plan?.leadSession ?? null;
   const leads = target.plan ? planLeads(target.plan) : null;
@@ -86049,7 +86063,7 @@ async function standing(io, values, args) {
       at: row.at,
       what: row.what
     }));
-    return emit(io, ok({ fanout, orders }), (data) => data.orders.length ? [
+    return emit(io, ok2({ fanout, orders }), (data) => data.orders.length ? [
       `standing orders for fanout ${fanout}:`,
       ...data.orders.map((o) => `  ${o.id}  ${o.what}`)
     ] : `no standing orders for fanout ${fanout}`);
@@ -86063,7 +86077,7 @@ async function standing(io, values, args) {
     ...values.supersedes ? { supersedes: values.supersedes } : {}
   };
   if (action === "add" && target.plan === null)
-    return emit(io, fail("not_found", `no fanout plan named ${fanout}`, {
+    return emit(io, fail2("not_found", `no fanout plan named ${fanout}`, {
       unblock: "workit fanout plan <plan.json> first, or name an existing plan with --fanout"
     }));
   if (action === "add")
@@ -86097,7 +86111,7 @@ var USAGE11 = "workit ledger decision|ruling|verdict|standing|list|check ... (wo
     return;
   const parsed = Number(value);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : new Error(`${flag} must be a positive integer`);
-}, failed2 = (io, result) => emit(io, fail(result.code, result.error, result.unblock ? { unblock: result.unblock } : {})), fromResult = (io, result, human) => result.ok ? emit(io, ok(result.value), human) : failed2(io, result), usage4 = (io, error) => emit(io, fail("invalid_input", error, { unblock: USAGE11 })), passedTestOn = (cwd, verdict) => {
+}, failed2 = (io, result) => emit(io, fail2(result.code, result.error, result.unblock ? { unblock: result.unblock } : {})), fromResult = (io, result, human) => result.ok ? emit(io, ok2(result.value), human) : failed2(io, result), usage4 = (io, error) => emit(io, fail2("invalid_input", error, { unblock: USAGE11 })), passedTestOn = (cwd, verdict) => {
   const ledger = readLedger(cwd);
   return ledger.ok && ledger.value.rows.some((row) => row.type === "check" && row.observer === "workit_cli" && row.name === "test" && row.result === "passed" && row.dirty !== true && row.branch === verdict.branch && row.head === verdict.head);
 }, verdictLines = (check) => {
@@ -86159,6 +86173,7 @@ var init_ledger2 = __esm(() => {
     evidence: { type: "string", multiple: true },
     self: { type: "boolean" },
     branch: { type: "string" },
+    head: { type: "string" },
     base: { type: "string" },
     pr: { type: "string" },
     type: { type: "string" },
@@ -102735,7 +102750,7 @@ function human(data) {
 async function run20(argv, io) {
   const options = parse7(argv);
   if (typeof options === "string")
-    return emit(io, fail("invalid_input", `${options}
+    return emit(io, fail2("invalid_input", `${options}
 usage: ${USAGE12}`));
   const top = git7(io.cwd, ["rev-parse", "--show-toplevel"]);
   const repo = top.ok ? path59.resolve(top.stdout.trim()) : null;
@@ -102744,12 +102759,12 @@ usage: ${USAGE12}`));
   let changed = null;
   if (options.diff || options.mutate) {
     if (!repo)
-      return emit(io, fail("unavailable", "--diff and --mutate need a git repository", {
+      return emit(io, fail2("unavailable", "--diff and --mutate need a git repository", {
         unblock: "run inside a git work tree"
       }));
     base = resolveBase(io.cwd, options.base);
     if (!base)
-      return emit(io, fail("invalid_input", `cannot resolve a base to diff against${options.base ? `: ${options.base}` : ""}`, {
+      return emit(io, fail2("invalid_input", `cannot resolve a base to diff against${options.base ? `: ${options.base}` : ""}`, {
         unblock: "workit test-audit --diff <base-branch-or-sha>"
       }));
     changed = changedLines(io.cwd, base);
@@ -102760,7 +102775,7 @@ usage: ${USAGE12}`));
   else {
     const expanded = expandPaths(io.cwd, options.paths);
     if (expanded.missing.length > 0)
-      return emit(io, fail("not_found", `no such path: ${expanded.missing.join(", ")}`));
+      return emit(io, fail2("not_found", `no such path: ${expanded.missing.join(", ")}`));
     files = expanded.files;
   }
   const report = auditFiles(files, display);
@@ -102778,7 +102793,7 @@ usage: ${USAGE12}`));
   if (options.mutate && repo && base && changed) {
     const runner = testCommand(repo, io.cwd, options.testCmd);
     if (!runner)
-      return emit(io, fail("unavailable", "no test command for --mutate", {
+      return emit(io, fail2("unavailable", "no test command for --mutate", {
         unblock: 'workit test-audit --mutate --test-cmd "<runner> {files}" (or configure a `test` check in .workit/checks.json)'
       }));
     try {
@@ -102797,7 +102812,7 @@ usage: ${USAGE12}`));
       });
     } catch (error) {
       if (error instanceof BaselineFailed)
-        return emit(io, fail("failed", error.message, {
+        return emit(io, fail2("failed", error.message, {
           data: { command: error.command, tail: error.tail },
           unblock: "make the related tests pass before mutating"
         }));
@@ -102818,9 +102833,9 @@ usage: ${USAGE12}`));
       for (const line of human(data))
         io.stdout(`${line}
 `);
-    return emit(io, fail("failed", problems.join("; "), { data }));
+    return emit(io, fail2("failed", problems.join("; "), { data }));
   }
-  return emit(io, ok(data), human);
+  return emit(io, ok2(data), human);
 }
 var USAGE12 = "workit test-audit [paths…] [--diff [base]] [--rule <ids>] [--min-severity <level>] [--fail-on <level>] [--mutate [--test-cmd <cmd>] [--max-mutants <n>] [--budget <s>] [--timeout <s>]] [--json]", LEVELS, VALUE_FLAGS2, quote = (arg) => /^[\w./@:=+-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, "'\\''")}'`;
 var init_test_audit = __esm(() => {
@@ -102848,16 +102863,16 @@ __export(exports_knowledge, {
 async function run21(argv, io) {
   const [sub, ...rest] = argv.filter((arg) => arg !== "--json");
   if (sub !== "lint" || rest.length > 0)
-    return emit(io, fail("invalid_input", `usage: ${USAGE13}`));
+    return emit(io, fail2("invalid_input", `usage: ${USAGE13}`));
   const report = lintKnowledge(checkRoot(io.cwd));
   if (report.unreadable.length > 0)
-    return emit(io, fail("unavailable", `knowledge lint: cannot read ${report.unreadable.join(", ")}`, {
+    return emit(io, fail2("unavailable", `knowledge lint: cannot read ${report.unreadable.join(", ")}`, {
       data: report,
       unblock: `make ${report.unreadable.join(", ")} readable, then re-run workit knowledge lint`
     }));
   const summary = `knowledge lint: ${report.findings.length} finding${report.findings.length === 1 ? "" : "s"} in ${report.files.length} file${report.files.length === 1 ? "" : "s"} (${report.files.map((file) => `${file.file} ${file.bytes} B`).join(", ") || "no knowledge files"}; AGENTS.md budget ${report.budget} B)`;
   if (io.json)
-    return emit(io, report.findings.length === 0 ? ok(report) : fail("failed", summary, { data: report }));
+    return emit(io, report.findings.length === 0 ? ok2(report) : fail2("failed", summary, { data: report }));
   for (const finding of report.findings)
     io.stdout(`${finding.file}${finding.line === null ? "" : `:${finding.line}`} [${finding.rule}] ${finding.message}
 `);
@@ -102932,7 +102947,7 @@ async function run22(argv, io) {
       return usage3(io, "the note is empty", USAGE14);
     const missing = step("comment", "comments", { operation: "note", issueId, markdown }, markdown, async (text) => commentResult(await postComment(issueId, text, root))) ?? (minutes ? step("time", "workItems", { operation: "note.time", issueId, markdown, minutes, ...markedDay }, "workit update", (text) => logTimeUpdate({ issueId, minutes, text, dateMs, workspace_root: root })) : null);
     if (missing)
-      return emit(io, fail("unavailable", missing));
+      return emit(io, fail2("unavailable", missing));
   } else {
     if (!minutes)
       return usage3(io, `${sub} needs --minutes <n>`, USAGE14);
@@ -102941,7 +102956,7 @@ async function run22(argv, io) {
     const text = flags.values.text ?? "";
     const missing = step(sub, "workItems", { operation: sub, issueId, minutes, text, ...markedDay }, text, (marked) => logTimeUpdate({ issueId, minutes, text: marked, dateMs, workspace_root: root }));
     if (missing)
-      return emit(io, fail("unavailable", missing));
+      return emit(io, fail2("unavailable", missing));
   }
   const results = [];
   for (const entry of steps) {
@@ -102954,14 +102969,14 @@ async function run22(argv, io) {
       } : {}
     });
     if (outcome.status === "failed" || outcome.status === "unknown")
-      return emit(io, fail(outcome.status === "unknown" ? "unavailable" : "failed", outcome.error, {
+      return emit(io, fail2(outcome.status === "unknown" ? "unavailable" : "failed", outcome.error, {
         data: { issueId, steps: results, ...outcome.data ? { detail: outcome.data } : {} },
         ...outcome.status === "unknown" ? {
           unblock: `check ${issueId} in YouTrack; re-running is safe (the marker skips a write that already landed)`
         } : {}
       }));
   }
-  return emit(io, ok({ issueId, date: date.data.localDate, steps: results }), (data) => [
+  return emit(io, ok2({ issueId, date: date.data.localDate, steps: results }), (data) => [
     `${issueId}: ${data.steps.map((entry) => `${entry.step} ${entry.status.replace("_", " ")}`).join(", ")} (${data.date})`,
     ...data.steps.flatMap((entry) => entry.note ? [`  note (${entry.step}): ${entry.note}`] : [])
   ]);
@@ -103027,14 +103042,14 @@ async function run23(argv, io) {
   if (flags.booleans.has("preview")) {
     const preview = changelogApplyPreview(input);
     if (preview.error)
-      return emit(io, fail("invalid_input", String(preview.error)));
+      return emit(io, fail2("invalid_input", String(preview.error)));
     const { after, ...summary } = preview;
-    return emit(io, ok({ ...summary, after }), () => [String(after)]);
+    return emit(io, ok2({ ...summary, after }), () => [String(after)]);
   }
   const applied = changelogApply(input);
   if (applied.error)
-    return emit(io, fail("failed", String(applied.error)));
-  return emit(io, ok(applied), () => [
+    return emit(io, fail2("failed", String(applied.error)));
+  return emit(io, ok2(applied), () => [
     `changelog updated: ${String(applied.path ?? "CHANGELOG.md")}`
   ]);
 }
@@ -103099,27 +103114,27 @@ async function resumeBrief(argv, io) {
       strict: true
     }));
   } catch (error) {
-    return emit(io, fail("invalid_input", error.message, { unblock: USAGE16 }));
+    return emit(io, fail2("invalid_input", error.message, { unblock: USAGE16 }));
   }
   const last = values.last === undefined ? 10 : Number(values.last);
   if (!Number.isInteger(last) || last < 1)
-    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE16 }));
+    return emit(io, fail2("invalid_input", "--last must be a positive integer", { unblock: USAGE16 }));
   const built = buildHandoff(io.cwd, {
     last,
     note: values.note ?? null,
     next: values.next ?? null
   });
   if (!built.ok)
-    return emit(io, fail(built.code, built.error, built.unblock ? { unblock: built.unblock } : {}));
+    return emit(io, fail2(built.code, built.error, built.unblock ? { unblock: built.unblock } : {}));
   const data = built.value;
   let recorded = null;
   if (values.record) {
     const row = recordHandoff({ cwd: io.cwd, actor: actorFromEnv(io.env), branch: data.branch }, { note: data.note, next: data.next });
     if (!row.ok)
-      return emit(io, fail(row.code, row.error, { data: { ...data, recorded } }));
+      return emit(io, fail2(row.code, row.error, { data: { ...data, recorded } }));
     recorded = row.value.id;
   }
-  return emit(io, ok({ ...data, recorded }), human2);
+  return emit(io, ok2({ ...data, recorded }), human2);
 }
 async function run24(argv, io) {
   if (!argv.some((arg) => arg === "--task" || arg.startsWith("--task=")))
@@ -103137,100 +103152,6 @@ var init_handoff = __esm(() => {
 init_package();
 import path62 from "node:path";
 
-// packages/workit-cli/src/help.ts
-var HELP_FLAGS = new Set(["--help", "-h"]);
-var ESCAPE = "A value that starts with - goes as --flag=value (or after a bare --).";
-var options = (args) => {
-  const end = args.indexOf("--");
-  return end < 0 ? args : args.slice(0, end);
-};
-var wantsHelp = (args) => options(args).some((arg) => HELP_FLAGS.has(arg));
-var firstWord = (args) => options(args).find((arg) => !arg.startsWith("-"));
-var valueFlags = (lines) => {
-  const out = new Map;
-  const group = /(?<![\w-])(--?[a-zA-Z][\w-]*(?:\|--?[a-zA-Z][\w-]*)*) (?=[<"a-z0-9])/gu;
-  for (const line of lines)
-    for (const match of line.matchAll(group)) {
-      const names = match[1].split("|");
-      const long = names.find((name) => name.startsWith("--")) ?? names[0];
-      for (const name of names)
-        out.set(name, long);
-    }
-  return out;
-};
-function helpAsValue(args, lines) {
-  const before = options(args);
-  const takes = valueFlags(lines);
-  for (let index = 1;index < before.length; index += 1) {
-    const flag = before[index];
-    const long = takes.get(before[index - 1]);
-    if (HELP_FLAGS.has(flag) && long)
-      return `\`${flag}\` looks like the value of ${before[index - 1]}; use ${long}=${flag} or put it after --`;
-  }
-  return null;
-}
-function takesPositionals(lines) {
-  const flag = /(?<![\w-])--?[a-zA-Z][\w-]*(?:\|--?[a-zA-Z][\w-]*)*(?:[ =](?!-)(?:<[^>]*>|"[^"]*"|[\w.,@/|=-]+)…?)?/gu;
-  return lines.some((line) => /<|"|\w…|\s…/u.test(line.replace(flag, "")));
-}
-var usageLines = (entry) => entry.subcommands?.length ? entry.subcommands.map((sub) => sub.usage) : [entry.usage];
-var examplesFor = (entry, sub) => (entry.examples ?? []).filter((example) => sub ? new RegExp(`^workit ${entry.name} ${sub.name}(?![\\w-])`, "u").test(example) : true);
-var exampleBlock = (examples) => examples.length ? ["", "examples:", ...examples.map((line) => `  ${line}`)] : [];
-var noteBlock = (entry) => (entry.notes ?? []).flatMap((note) => ["", note]);
-function verbHelp(entry) {
-  const subs = entry.subcommands ?? [];
-  const usages = usageLines(entry);
-  const examples = examplesFor(entry);
-  const text = [
-    ...subs.length ? [
-      `workit ${entry.name}: ${entry.summary}`,
-      "",
-      ...subs.flatMap((sub) => [`usage: ${sub.usage}`, `    ${sub.summary}`])
-    ] : [`usage: ${entry.usage}`, "", entry.summary],
-    ...noteBlock(entry),
-    ...exampleBlock(examples),
-    "",
-    ...subs.length ? [`More: workit help ${entry.name} <${subs.map((sub) => sub.name).join("|")}>`] : [],
-    ESCAPE
-  ].join(`
-`);
-  return {
-    name: entry.name,
-    group: entry.group,
-    usage: usages[0],
-    usages,
-    summary: entry.summary,
-    examples,
-    text
-  };
-}
-function subcommandHelp(entry, sub) {
-  const examples = examplesFor(entry, sub);
-  return {
-    name: entry.name,
-    group: entry.group,
-    subcommand: sub.name,
-    usage: sub.usage,
-    usages: [sub.usage],
-    summary: sub.summary,
-    examples,
-    text: [
-      `usage: ${sub.usage}`,
-      "",
-      sub.summary,
-      ...noteBlock(entry),
-      ...exampleBlock(examples),
-      "",
-      ...sub.aliases?.length ? [`aliases: ${sub.aliases.join(", ")}`] : [],
-      ESCAPE
-    ].join(`
-`)
-  };
-}
-
-// packages/workit-cli/src/main.ts
-init_output();
-
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
   "task",
@@ -103300,7 +103221,7 @@ var familySubcommands = (name) => {
   const implicit = name === "task" ? TASK_IMPLICIT : [];
   const grammar = Object.entries(FAMILY_ACTIONS[name]).filter(([action]) => !implicit.some((entry) => entry.name === action)).map(([action, summary]) => ({
     name: action,
-    usage: name === "policy" && action !== "explain" ? `workit policy ${action} ${POLICY_JUDGE} ${FAMILY_OPTIONS}` : name === "worker" && action !== "assign" ? `workit worker ${action} [<workerId>] ${FAMILY_OPTIONS}` : `workit ${name} ${action} ${FAMILY_OPTIONS}`,
+    usage: name === "task" && action === "list" ? `workit task list [--status all] ${FAMILY_OPTIONS}` : name === "policy" && action !== "explain" ? `workit policy ${action} ${POLICY_JUDGE} ${FAMILY_OPTIONS}` : name === "worker" && action !== "assign" ? `workit worker ${action} [<workerId>] ${FAMILY_OPTIONS}` : `workit ${name} ${action} ${FAMILY_OPTIONS}`,
     summary
   }));
   return [...implicit, ...grammar];
@@ -103356,6 +103277,7 @@ var VERBS = [
   {
     name: "launch",
     group: "setup",
+    passthrough: true,
     usage: "workit launch <host> [--auto-upgrade] [-- <host args…>]",
     summary: "Upgrade before host startup, then start the host",
     load: () => Promise.resolve().then(() => (init_launch(), exports_launch))
@@ -103410,6 +103332,9 @@ var VERBS = [
     name: "check",
     group: "delivery",
     usage: 'workit check <name> [--task <id>] [--base <ref>] [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--timeout <s>] [--task <id>] [--base <ref>] [--heavy [--wait <s>]] [--no-lease --reason "<why>"] -- <cmd…>',
+    flagHints: {
+      list: "workit check <name> runs a configured check; a name that is not configured prints the valid ones (workit check test|lint|typecheck|check)"
+    },
     summary: "Run a configured or ad-hoc check and record CLI-observed evidence (exit = the command's); heavy checks wait for the machine-wide heavy-check lease",
     examples: [
       "workit check test",
@@ -103468,6 +103393,9 @@ var VERBS = [
       },
       {
         name: "create",
+        flagHints: {
+          head: "pr create opens the PR for the current branch: git switch <branch>, then workit pr create (--base sets the target)"
+        },
         usage: "workit pr create [--base <b> | --track <t>] (--title <t> [--body <text> | --body-file <f|->] | --fill) [--issue <#n|ID|url>]… [--refs] [--label <l>]… [--reviewer <login>]… [--draft]",
         summary: "Open a PR/MR for the pushed branch, verified against the local HEAD, linking its issues"
       },
@@ -103539,6 +103467,7 @@ var VERBS = [
       },
       {
         name: "push",
+        deferredFlags: ["force"],
         usage: "workit git push [-u|--set-upstream] [--force-with-lease [--expect <sha>] [--overwrite-unintegrated]] [--release <main|develop|v-tag>…]",
         summary: "Push the current branch and verify the remote tip (never a blind --force); --release finishes a git-flow release"
       },
@@ -103640,26 +103569,31 @@ var VERBS = [
     subcommands: [
       {
         name: "plan",
+        flagAliases: { fanout: "name" },
         usage: "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] [--take-lead]",
         summary: "Register the slices of a plan file"
       },
       {
         name: "brief",
+        flagAliases: { fanout: "name" },
         usage: "workit fanout brief <slice> [--mode new|resume] [--attempt <n>] [--name <n>]",
         summary: "Render one worker's brief with the standing orders"
       },
       {
         name: "check",
+        flagAliases: { fanout: "name" },
         usage: "workit fanout check [<slice>…] [--name <n>] [--base <ref>] [--offline]",
         summary: "Gate fan-in: out-of-scope edits, trunk and sibling merge conflicts"
       },
       {
         name: "status",
+        flagAliases: { fanout: "name" },
         usage: "workit fanout status [--name <n>] [--stuck-after 30m] [--offline]",
         summary: "Each slice's state: STUCK, PR, CI, verdict, landed, landing order"
       },
       {
         name: "worktree",
+        flagAliases: { fanout: "name" },
         usage: "workit fanout worktree create|release <slice> [--name <n>] [--force]",
         summary: "Make or release a slice's worktree (--force applies to release only)"
       }
@@ -103673,6 +103607,7 @@ var VERBS = [
   withSubcommands({
     name: "ledger",
     group: "delivery",
+    sharedParser: true,
     summary: "Record and query decisions, rulings, SHA-keyed verdicts (patch-id carry-over across rebases) and a fanout's standing orders",
     subcommands: [
       {
@@ -103687,7 +103622,11 @@ var VERBS = [
       },
       {
         name: "verdict",
-        usage: `workit ledger verdict <result> --how "<method/evidence>" [--kind unit|live|perf|review] [--base <ref>] [--surface ui|cli|api] [--evidence <ref>]… [--self] ${LEDGER_ACTOR} | ledger verdict [<branch>]`,
+        flagAliases: { sha: "head" },
+        flagHints: {
+          repo: "a verdict is recorded in the checkout you run it from: cd into the repo or pass --cwd <dir>"
+        },
+        usage: `workit ledger verdict <result> --how "<method/evidence>" [--head <sha>] [--kind unit|live|perf|review] [--base <ref>] [--surface ui|cli|api] [--evidence <ref>]… [--self] ${LEDGER_ACTOR} | ledger verdict [<branch>]`,
         summary: "Record a SHA-keyed verdict on the branch head (result: verified, tests-verified, type-check-only, blocked, failed), or show the current verdicts"
       },
       {
@@ -103708,6 +103647,7 @@ var VERBS = [
       },
       {
         name: "standing",
+        flagAliases: { name: "fanout" },
         usage: `workit ledger standing add "<order>" | standing list | standing clear [<id>]  [--fanout <name>] [--supersedes <id>] [--session <id> [--token <t>] | --as <role>]`,
         summary: "The lead's standing orders for a fanout's workers"
       },
@@ -103791,7 +103731,179 @@ var BY_NAME = new Map(VERBS.map((entry) => [entry.name, entry]));
 var findVerb = (name) => BY_NAME.get(name);
 var findSubcommand = (entry, name) => entry.subcommands?.find((sub) => sub.name === name || sub.aliases?.includes(name));
 
+// packages/workit-cli/src/help.ts
+var HELP_FLAGS = new Set(["--help", "-h"]);
+var ESCAPE2 = "A value that starts with - goes as --flag=value (or after a bare --).";
+var options = (args) => {
+  const end = args.indexOf("--");
+  return end < 0 ? args : args.slice(0, end);
+};
+var wantsHelp = (args) => options(args).some((arg) => HELP_FLAGS.has(arg));
+var firstWord = (args) => options(args).find((arg) => !arg.startsWith("-"));
+var valueFlags = (lines) => {
+  const out = new Map;
+  const group = /(?<![\w-])(--?[a-zA-Z][\w-]*(?:\|--?[a-zA-Z][\w-]*)*) (?=[<"a-z0-9])/gu;
+  for (const line of lines)
+    for (const match of line.matchAll(group)) {
+      const names = match[1].split("|");
+      const long = names.find((name) => name.startsWith("--")) ?? names[0];
+      for (const name of names)
+        out.set(name, long);
+    }
+  return out;
+};
+function helpAsValue(args, lines) {
+  const before = options(args);
+  const takes = valueFlags(lines);
+  for (let index = 1;index < before.length; index += 1) {
+    const flag = before[index];
+    const long = takes.get(before[index - 1]);
+    if (HELP_FLAGS.has(flag) && long)
+      return `\`${flag}\` looks like the value of ${before[index - 1]}; use ${long}=${flag} or put it after --`;
+  }
+  return null;
+}
+function takesPositionals(lines) {
+  const flag = /(?<![\w-])--?[a-zA-Z][\w-]*(?:\|--?[a-zA-Z][\w-]*)*(?:[ =](?!-)(?:<[^>]*>|"[^"]*"|[\w.,@/|=-]+)…?)?/gu;
+  return lines.some((line) => /<|"|\w…|\s…/u.test(line.replace(flag, "")));
+}
+var usageLines = (entry) => entry.subcommands?.length ? entry.subcommands.map((sub) => sub.usage) : [entry.usage];
+var examplesFor = (entry, sub) => (entry.examples ?? []).filter((example) => sub ? new RegExp(`^workit ${entry.name} ${sub.name}(?![\\w-])`, "u").test(example) : true);
+var exampleBlock = (examples) => examples.length ? ["", "examples:", ...examples.map((line) => `  ${line}`)] : [];
+var noteBlock = (entry) => (entry.notes ?? []).flatMap((note) => ["", note]);
+function verbHelp(entry) {
+  const subs = entry.subcommands ?? [];
+  const usages = usageLines(entry);
+  const examples = examplesFor(entry);
+  const text = [
+    ...subs.length ? [
+      `workit ${entry.name}: ${entry.summary}`,
+      "",
+      ...subs.flatMap((sub) => [`usage: ${sub.usage}`, `    ${sub.summary}`])
+    ] : [`usage: ${entry.usage}`, "", entry.summary],
+    ...noteBlock(entry),
+    ...exampleBlock(examples),
+    "",
+    ...subs.length ? [`More: workit help ${entry.name} <${subs.map((sub) => sub.name).join("|")}>`] : [],
+    ESCAPE2
+  ].join(`
+`);
+  return {
+    name: entry.name,
+    group: entry.group,
+    usage: usages[0],
+    usages,
+    summary: entry.summary,
+    examples,
+    text
+  };
+}
+function subcommandHelp(entry, sub) {
+  const examples = examplesFor(entry, sub);
+  return {
+    name: entry.name,
+    group: entry.group,
+    subcommand: sub.name,
+    usage: sub.usage,
+    usages: [sub.usage],
+    summary: sub.summary,
+    examples,
+    text: [
+      `usage: ${sub.usage}`,
+      "",
+      sub.summary,
+      ...noteBlock(entry),
+      ...exampleBlock(examples),
+      "",
+      ...sub.aliases?.length ? [`aliases: ${sub.aliases.join(", ")}`] : [],
+      ESCAPE2
+    ].join(`
+`)
+  };
+}
+var distance = (left, right) => {
+  let row = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let i = 1;i <= left.length; i += 1) {
+    const next = [i];
+    for (let j = 1;j <= right.length; j += 1)
+      next[j] = Math.min(row[j] + 1, next[j - 1] + 1, row[j - 1] + (left[i - 1] === right[j - 1] ? 0 : 1));
+    row = next;
+  }
+  return row[right.length];
+};
+function closest(word, candidates) {
+  let best = null;
+  let bestScore = Infinity;
+  for (const candidate of candidates) {
+    const near = distance(word, candidate);
+    const score = candidate.startsWith(word) || word.startsWith(candidate) ? Math.min(near, 1) : near;
+    if (score < bestScore) {
+      best = candidate;
+      bestScore = score;
+    }
+  }
+  return best !== null && bestScore <= Math.max(2, Math.floor(word.length / 3)) ? best : null;
+}
+var COMMAND_HINTS = {
+  status: "workit task status (this branch's task) or workit pr status (its PR); workit handoff prints the whole picture",
+  context: "workit handoff prints the branch, HEAD, dirty state, verdict and next command"
+};
+function commandUnblock(command) {
+  const near = closest(command, VERBS.filter((entry) => !entry.planned).map((entry) => entry.name));
+  return COMMAND_HINTS[command] ?? (near ? `did you mean workit ${near}? (workit help)` : "workit help");
+}
+var LONG_FLAG = /^--([a-zA-Z][\w-]*)(=|$)/u;
+var GLOBAL_FLAGS = new Set(["json", "cwd", "help"]);
+function checkFlags(entry, args) {
+  const word = firstWord(args);
+  const sub = word === undefined ? undefined : findSubcommand(entry, word);
+  const lines = sub && !entry.sharedParser && !/ …/u.test(sub.usage) ? [sub.usage] : usageLines(entry);
+  const takes = valueFlags(lines);
+  const known = new Set;
+  for (const line of lines)
+    for (const match of line.matchAll(/(?<![\w-])--([a-zA-Z][\w-]*)/gu))
+      known.add(match[1]);
+  const aliases = { ...entry.flagAliases, ...sub?.flagAliases };
+  const hints = { ...entry.flagHints, ...sub?.flagHints };
+  for (const flag of sub?.deferredFlags ?? [])
+    known.add(flag);
+  const where = `workit help ${entry.name}${sub ? ` ${sub.name}` : ""}`;
+  const out = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--") {
+      out.push(...args.slice(index));
+      break;
+    }
+    if (entry.passthrough && !arg.startsWith("-")) {
+      out.push(...args.slice(index));
+      break;
+    }
+    if (takes.has(arg) && index + 1 < args.length && args[index + 1] !== "--") {
+      out.push(arg, args[index += 1]);
+      continue;
+    }
+    const match = LONG_FLAG.exec(arg);
+    if (!match || GLOBAL_FLAGS.has(match[1]) || known.has(match[1])) {
+      out.push(arg);
+      continue;
+    }
+    const canonical = aliases[match[1]];
+    if (canonical !== undefined) {
+      out.push(`--${canonical}${arg.slice(match[0].length - match[2].length)}`);
+      continue;
+    }
+    const near = closest(match[1], known);
+    return {
+      error: `unknown option --${match[1]}`,
+      unblock: hints[match[1]] ?? (near ? `did you mean --${near}? (${where})` : where)
+    };
+  }
+  return { args: out };
+}
+
 // packages/workit-cli/src/main.ts
+init_output();
 var GROUP_TITLES = {
   setup: "Setup",
   task: "Task control",
@@ -103870,11 +103982,11 @@ async function main(argv, overrides = {}, options = {}) {
   const cwd = path62.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   const io = { ...defaultIo(parsed.json), ...overrides, json: parsed.json, cwd };
   if (parsed.error)
-    return emit(io, fail("invalid_input", parsed.error));
+    return emit(io, fail2("invalid_input", parsed.error));
   const [command, ...verbArgs] = parsed.rest;
   const args = parsed.json && !verbArgs.includes("--json") ? withJsonFlag(verbArgs) : verbArgs;
   if (command === "--version" || command === "-v" || command === "version") {
-    return emit(io, ok({ version: package_default.version }), (data) => data.version);
+    return emit(io, ok2({ version: package_default.version }), (data) => data.version);
   }
   if (command === undefined || command === "help" || command === "--help" || command === "-h") {
     const [topic, sub] = command === "help" ? words2(args) : [];
@@ -103886,12 +103998,12 @@ async function main(argv, overrides = {}, options = {}) {
         return help(io, verbHelp(entry));
       const found = findSubcommand(entry, sub);
       if (!found)
-        return emit(io, fail("invalid_input", `unknown ${topic} subcommand "${sub}"`, {
+        return emit(io, fail2("invalid_input", `unknown ${topic} subcommand "${sub}"`, {
           unblock: `workit help ${topic}`
         }));
       return help(io, subcommandHelp(entry, found));
     }
-    return emit(io, ok({ version: package_default.version, verbs: listed().map(describe3) }), () => helpText());
+    return emit(io, ok2({ version: package_default.version, verbs: listed().map(describe3) }), () => helpText());
   }
   const entry = findVerb(command);
   if (!entry)
@@ -103901,7 +104013,7 @@ async function main(argv, overrides = {}, options = {}) {
     const sub = word === undefined ? undefined : findSubcommand(entry, word);
     const asValue = helpAsValue(verbArgs, sub ? [sub.usage] : usageLines(entry));
     if (asValue)
-      return emit(io, fail("invalid_input", asValue, {
+      return emit(io, fail2("invalid_input", asValue, {
         unblock: `workit help ${entry.name}${sub ? ` ${sub.name}` : ""}`
       }));
     return help(io, sub ? subcommandHelp(entry, sub) : verbHelp(entry));
@@ -103909,11 +104021,14 @@ async function main(argv, overrides = {}, options = {}) {
   const ended = endOfOptions(io, entry, args);
   if (typeof ended === "number")
     return ended;
+  const checked = checkFlags(entry, ended);
+  if ("error" in checked)
+    return emit(io, fail2("invalid_input", checked.error, { unblock: checked.unblock }));
   if (parsed.cwd !== null) {
     try {
       process.chdir(io.cwd);
     } catch {
-      return emit(io, fail("invalid_input", `--cwd: cannot enter ${io.cwd}`));
+      return emit(io, fail2("invalid_input", `--cwd: cannot enter ${io.cwd}`));
     }
     if (process.env.WORKFLOW_WORKSPACE_ROOT !== undefined) {
       process.env.WORKFLOW_WORKSPACE_ROOT = io.cwd;
@@ -103925,7 +104040,7 @@ async function main(argv, overrides = {}, options = {}) {
   globalThis[Symbol.for("workit.migrationReporter")] = (report) => io.stderr(`workit: migrated ${report.tasks} task${report.tasks === 1 ? "" : "s"} from ${report.from} to ${report.to} (backup: ${report.backup})
 `);
   const verb = await entry.load();
-  const runVerb = (target) => guarded(target, () => verb.run(ended, target));
+  const runVerb = (target) => guarded(target, () => verb.run(checked.args, target));
   if (!io.json)
     return runVerb(io);
   return runJsonPure(io, command, runVerb);
@@ -103936,7 +104051,7 @@ async function guarded(io, run) {
   } catch (error) {
     if (!(error instanceof Error) || error.name !== "WorkspaceConfigError")
       throw error;
-    return emit(io, fail("blocked", error.message, {
+    return emit(io, fail2("blocked", error.message, {
       unblock: "fix ~/.config/workit/workspaces.json (workit init → Workspaces)"
     }));
   }
@@ -103991,7 +104106,7 @@ async function runJsonPure(io, command, run) {
     io.stderr(buffered.endsWith(`
 `) ? buffered : `${buffered}
 `);
-  const envelope = code === 0 ? ok(text ? { text } : {}) : fail(CODE_FOR_EXIT[code] ?? "failed", text.split(`
+  const envelope = code === 0 ? ok2(text ? { text } : {}) : fail2(CODE_FOR_EXIT[code] ?? "failed", text.split(`
 `)[0] || `${command} exited with ${code}`);
   io.stdout(`${JSON.stringify(envelope)}
 `);
@@ -104012,17 +104127,17 @@ function endOfOptions(io, entry, args) {
   if (entry.subcommands?.length && !sub) {
     if (entry.optionalSubcommand || word !== undefined)
       return args;
-    return emit(io, fail("invalid_input", `missing ${entry.name} subcommand`, { unblock }));
+    return emit(io, fail2("invalid_input", `missing ${entry.name} subcommand`, { unblock }));
   }
   if (takesPositionals(sub ? [sub.usage] : [entry.usage]))
     return args;
   const extra = args.slice(end + 1);
   if (extra.length)
-    return emit(io, fail("invalid_input", `${entry.name}${sub ? ` ${sub.name}` : ""} takes no positional arguments (got: ${extra.join(" ")})`, { unblock }));
+    return emit(io, fail2("invalid_input", `${entry.name}${sub ? ` ${sub.name}` : ""} takes no positional arguments (got: ${extra.join(" ")})`, { unblock }));
   return args.slice(0, end);
 }
 var words2 = (args) => args.filter((arg) => !arg.startsWith("-"));
-var help = (io, doc) => emit(io, ok(doc), (data) => data.text);
+var help = (io, doc) => emit(io, ok2(doc), (data) => data.text);
 var describe3 = (entry) => ({
   name: entry.name,
   group: entry.group,
@@ -104031,7 +104146,7 @@ var describe3 = (entry) => ({
   summary: entry.summary,
   ...entry.planned ? { planned: entry.planned } : {}
 });
-var unknown2 = (io, command) => emit(io, fail("invalid_input", `unknown command "${command}"`, { unblock: "workit help" }));
+var unknown2 = (io, command) => emit(io, fail2("invalid_input", `unknown command "${command}"`, { unblock: commandUnblock(command) }));
 if (__require.main == __require.module) {
   process.exit(await main(process.argv.slice(2), {}, { diagnostics: true }));
 }