tldr-experts 0.18.3 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.19.0 — 2026-09-13
+
+### Added
+
+- **`tldrx story reopen <id> --as-is --note "…"` settles a story a person finished BY HAND
+  from its branch as it stands, with no developer spawned (#279).** Measured on a real
+  unattended run at 0.18.2: S2's merge into its epic hit the #268 conflict, a person rebased
+  the branch by hand (DoD green, `git merge-tree` clean), and then there was no way to get that
+  branch merged. `story reopen` hands the story to a developer; the developer had nothing to
+  do; #271's rule — work is measured SINCE THE SPAWN — blocked the story after one attempt,
+  correctly, because work that already exists, older than the spawn, is indistinguishable from
+  a developer that did nothing. A second reopen buys the same outcome, so the only way out was
+  to invent a commit for the developer to make. This is the case that rule could not see, added
+  beside it and not carved out of it: `--as-is` spawns nothing at all, so there is no spawn to
+  measure work since. Everything after the missing developer is the path every other story
+  takes — the epic is merged in if it moved (#268), the DoD runs in the story's worktree, the
+  same reviewer judges the same diff, the same merge lands it. The worktree is found BY NAME
+  from the branch and reopened when the build had removed it, which is the ordinary case: a
+  blocked story's tree is pruned as it settles, and the hand fix is typically made in a scratch
+  worktree that is then removed. Two refusals are STRUCTURAL and no flag skips either, because
+  a verb that merges a branch nobody's agent wrote is exactly where a `--force` gets added at
+  3 a.m. to unstick a run: the branch must carry at least one commit its epic has not already
+  got (`commitsBetween`, whose `null` stays "could not count" and refuses rather than reading
+  as "did not move", #273), and the DoD must go green under the same `dodProves` every other
+  story faces — the story blocks with the reason naming which. And the record does not lie
+  about who did the work (§7): `story.reopened` carries `reason: as_is` with the actor and the
+  note, `task.done` carries `as_is`/`as_is_by`/`as_is_note`, the review log's developer line
+  opens **none** and names the branch it took and the person who signed for it, and no task row
+  is written for a turn nothing was spawned for. The signature is cleared the moment a real
+  developer attempt starts, so a story requeued after a `changes` verdict over a hand-finished
+  branch records a DEVELOPER and not an as-is — found by review before it shipped, and pinned.
+  `--for-fix` and `--as-is` together are a usage error rather than a resolution in favour of
+  one: they answer different questions, and quietly performing the other is the CLI reporting
+  success for work it did not do. `tldrx next --prepare` refuses an `--as-is` story rather than
+  dispatching a developer bundle for it.
+
 ## 0.18.3 — 2026-09-13
 
 ### Fixed

package/README.md

@@ -331,6 +331,7 @@ back on the registry is 0.3.0.
 
 | Version | Date | Status | Contains |
 |---|---|---|---|
+| 0.19.0 | 2026-09-13 | `beta` | `tldrx story reopen <id> --as-is --note "…"` settles a story a person finished by hand from its branch as it stands, spawning no developer — measured on a live unattended run where a hand-rebased branch had a green DoD and a clean merge-tree but no way to land, blocked by #271's since-the-spawn rule from a developer with nothing to do (#279). Everything after the missing developer is the ordinary path: the epic merges in first if it moved, the same DoD and reviewer judge the diff, the same merge lands it. The record never lies about who did the work — `story.reopened` carries `reason: as_is` with the actor and note, `task.done` carries `as_is`/`as_is_by`/`as_is_note`, and the review log names the branch and the signer. Two refusals are structural with no flag to skip either: a branch with no commit ahead of its epic, and a red DoD. The signature clears the moment a real developer attempt starts, so a requeued story after a `changes` verdict records a developer, not an as-is. Minor release: a new flag, `--as-is`, on `story reopen`. |
 | 0.18.3 | 2026-09-13 | `beta` | four fixes to the unattended build path, all measured on live runs: a headless permission refusal is now classified — a chained shell command, a git verb outside the developer's allowance, or neither — so a chained line gets one retry with the cure stated first, an ungranted verb names its granted equivalent, and the developer prompt now lists the git verbs it holds from the one constant the grant is built from, after six refusals in one day left a ledger that recorded the symptom and not the cause; a wave no longer merges a story into its epic from the base it was cut from once a sibling has moved that epic — the story is measured against the epic tip immediately before merge, the epic is merged into the story and its Definition of Done re-run only when the epic actually moved, and a conflict blocks the story naming the files rather than merging half of one; a seed bullet over the claim cap no longer has its citation cut in half, with the clip moving back to the citation's start instead; and a failed commit count is no longer read as zero, so `--discard-pending` can no longer delete a plan just because git could not answer. |
 | 0.18.2 | 2026-09-13 | `beta` | three things measured on the first fully unattended run and on the live runs that followed it, one of them a regression 0.18.1 shipped hours earlier: `--ship merge` armed GitHub's auto-merge over a base that required nothing — the guard counted the checks the PR REPORTED while `--auto` waits on the base's REQUIREMENTS, so a proof run's pull request merged at 06:20:14 while all four of its checks finished between 06:21:38 and 06:24:56, and the record said `queued — GitHub merges when its checks pass`; ship now asks the base what it requires through rulesets and classic protection, names its three absences apart, and every unreadable answer arms nothing; the plan's per-story price had become a hard wall at 0.8x the planner's guess once 0.18.1 made those fields actually read, killing stories mid-flight at $1.28 and $3.25 against real costs an order of magnitude higher, so the ceiling is now `max(price x 3, $4.00)` derived at DISPATCH from the budget as it sits on disk — a run already in flight is covered without migrating anything — and, the half that carries the expensive end, a developer that dies on its cap with work in its tree commits it and lets the Definition of Done decide instead of parking the story, the same authority #271 gave a refused one; and the zero-touch recipe is written down where a person looks for it, seed file to backgrounded loop, on the README quick start and both documentation sites, with the honest boundary that this is the happy path without a person |
 | 0.18.1 | 2026-09-13 | `beta` | five things a run could not survive on its own, every one measured on the unattended proof runs that followed 0.18.0 rather than reasoned about: a priced plan was never priced — the planner wrote `stories[].estimate_usd` and Build read only `per_phase_usd` + `spent_usd`, so every story got the same $5.40 cap while the plan said $28, and the contract now names the shape and the plan check refuses a budget.yml that does not carry it; a headless refusal under a host-tokens ceiling wrote nothing to the ledger, so `--until-done` relaunched over a refusal it could not see, and now writes its `budget.blocked` first; a developer that had committed its work and was then refused a compound verification command was blocked BEFORE the facilitator ran the Definition of Done, so the DoD now decides when there is work and the refusal is recorded either way, with the prompt saying to run each DoD command verbatim and alone because shell separators split a line into subcommands that each need their own grant; a workspace can declare `<slot>_scoped` DoD commands that run per story on the paths it touched with the full suite once per epic head, after the full suite was measured running three times per story attempt; and a cancelled run no longer leaves an epic branch that refuses the ordinary retry — `run cancel` releases it and Build renames aside an epic whose owner run is closed, while an open or unknown owner still refuses verbatim and an uncounted branch is never deleted |

package/dist/tldrx.js

@@ -16427,11 +16427,18 @@ var ENTRIES = [
         meaning: "Open a FIX ROUND on a story that is `done`: one named defect in work a reviewer already approved. No attempt is consumed, the fix passes the same dod and the same reviewer as the original, and the story's acceptance criteria are not touched — it is not a way to relitigate scope. Refused when the story is not done, when --note is missing, and when that story already has a fix round open (the bound is one).",
         sub: "reopen"
       },
+      {
+        name: "as-is",
+        arg: null,
+        meaning: "Settle the story from its BRANCH AS IT STANDS: the next Build turn runs the dod, the review and the merge over the commits already on `story/<run>/<id>`, and spawns NO developer. For a story a person finished by hand — a rebase after a conflict, a fix typed directly on the branch — which the plain verb cannot land, because a developer handed finished work has nothing to do and the story blocks on the no-work rule. It is not a shortcut past a gate: a red dod blocks the story, and so does a branch carrying no commit its epic has not already got. Requires --note; refused together with --for-fix.",
+        sub: "reopen"
+      },
       runFlag(),
       root()
     ],
     examples: [
       'tldrx story reopen S3 --note "it gates wave 3 (S4, S6) and the owner has decided it ships"',
+      'tldrx story reopen S2 --as-is --note "rebased onto the epic by hand after the merge conflict; dod green"',
       'tldrx story reopen S11 --for-fix --note "linkEmail succeeds then setDisplayName fails: account linked, score never claimable"',
       'tldrx story widen S3 platform/Auth.cs --note "the tenancy check the story is for lives here too"'
     ],
@@ -16442,6 +16449,7 @@ var ENTRIES = [
       "The story goes back to `todo` and its attempt counter restarts at 1 of 2. Nothing is erased to make that true: `story.reopened` is a reset boundary the review ledger reads, every earlier attempt stays in events.jsonl, and the event records how many verdicts the closed run consumed.",
       "It runs no agent, spends nothing, deletes nothing and refunds nothing. The story's branch is kept — that is what carries the last developer's commits forward — and its worktree is left exactly as the build left it, to be reopened from the branch if the build had removed it.",
       'It does NOT make the stage runnable. If the Build stage is at its gate, `tldrx reject --note "…"` sends it back to `ready` first; if the gate is already signed, `tldrx reject --stage` takes that back.',
+      "`--as-is` is the other arc the plain verb cannot cover: a story a PERSON finished. `reopen` hands the story to a developer, and a developer handed a branch whose work is already done has nothing to commit — the story then blocks on the rule that measures work SINCE THE SPAWN, because work older than the spawn cannot be told apart from a developer that did nothing. `--as-is` spawns nothing at all, so there is nothing to measure: the dod runs in the story's worktree (reopened from the branch when the build had removed it), the reviewer judges the same diff, and the merge into the epic is the same merge. It records `story.reopened` with `reason: as_is`, and the story's row and review log say the branch was taken as it stands and name who signed that — no record claims a developer delivered it.",
       "`widen` adds paths to a story's `touches:` — the sanctioned form of the advice the boundary decision card gives when a Build stage changed a path nobody scoped. Widenable states are `todo`, `in_progress`, `review` and `blocked`. A `done` story refuses: its evidence was written against the surface it DECLARED, and widening it afterwards would make the record say the plan declared a path it did not — reopen it with `--for-fix` first. A path the story already declares refuses too, because a widening that widened nothing is a record of something that did not happen.",
       "`widen` runs no agent, spends nothing, consumes no attempt, changes no status and moves no cursor — it declares scope and nothing else. No gate code knows about it: the boundary condition re-reads `touches:` off disk at evaluation time, so the same run, the same branch and the same diff simply stop counting the widened path as outside the surface at the next evaluation. One `story.touches_widened` records the paths, the note and the list before and after."
     ]
@@ -26402,6 +26410,11 @@ function dodRefused(result2) {
 }
 var DOD_REFUSAL_FALLBACK = "the gate declined to run it";
 var DEVELOPER_FAILED = "the developer sub-agent failed";
+var AS_IS_MARK = "the branch was taken AS IT STANDS — no developer was spawned for it";
+var AS_IS_NOT_AHEAD_MARK = "nothing to take as it stands";
+function asIsNotAheadReason(branch, epicBranch, ahead) {
+  return ahead === null ? `${AS_IS_NOT_AHEAD_MARK}: git could not count what \`${branch}\` carries beyond ` + `\`${epicBranch}\`, and a settlement that spawns no developer will not merge on a ` + "measurement it does not have. Nothing was merged" : `${AS_IS_NOT_AHEAD_MARK}: \`${branch}\` carries no commit \`${epicBranch}\` has not already ` + "got, so there is no work to settle. Commit the fix to the story branch first, then reopen it " + "--as-is. Nothing was merged";
+}
 function scopedNote(result2) {
   if (result2.scope !== "paths" || result2.rendered === undefined)
     return "";
@@ -28877,6 +28890,7 @@ function renderReviewLog(outcome) {
     `- Repo: \`${outcome.repo}\` · wave ${outcome.wave} · epic ${outcome.epic}`,
     `- Branch: \`${outcome.branch}\` → \`${outcome.epicBranch}\` (${mergeWord(outcome)})`,
     `- Commit: ${outcome.commit ?? "(none)"}`,
+    ...outcome.asIs == null ? [] : [`- Developer: **none** — ${AS_IS_MARK}. \`${outcome.branch}\` was settled as it stands, ` + `signed by ${outcome.asIs.actor}: ${outcome.asIs.note}. The Definition of Done below and ` + "the reviewer above judged that branch, unchanged."],
     ...outcome.developerError === null ? [] : [`- Developer: **FAILED** — ${outcome.developerError}`],
     ...outcome.permissionRefused == null ? [] : [withCure(`- Developer: \`${outcome.permissionRefused}\` was refused for approval by the agent's own ` + "permission layer; the tree held committed work, so the Definition of Done below decided", outcome.permissionRefused)],
     ...outcome.budgetDeath == null ? [] : [`- Developer: died on its per-story cap — ${outcome.budgetDeath}; the tree held work, ` + "so the Definition of Done below decided"],
@@ -36457,6 +36471,7 @@ function readReviewLedger(runDir, storyId) {
     developerErroredWith: null,
     blockedWithNothingRun: false,
     reopened: null,
+    asIs: null,
     fixRound: null,
     formatRetries: 0,
     formatRefusal: null,
@@ -36477,6 +36492,7 @@ function readReviewLedger(runDir, storyId) {
   let current = [];
   let lastDodOutputPath = null;
   let reopened = null;
+  let asIs = null;
   let fixRound = null;
   let formatRetries = 0;
   let formatRefusal = null;
@@ -36514,6 +36530,7 @@ function readReviewLedger(runDir, storyId) {
       };
       if (payload.reason === "fix")
         fixRound = reopened;
+      asIs = payload.reason === "as_is" ? reopened : null;
       formatRetries = 0;
       formatRefusal = null;
       spawned = null;
@@ -36545,6 +36562,7 @@ function readReviewLedger(runDir, storyId) {
         epicBase = payload.epic_base;
       if (payload.status === "done")
         fixRound = null;
+      asIs = null;
       blockedWithNothingRun = payload.status === "blocked" && payload.verdict === "n-a" && (payload.commit === null || payload.commit === undefined || payload.commit === "") && !ranACheck && !sawReviewer;
     }
     if (event4.type !== "check.passed" && event4.type !== "check.failed")
@@ -36604,6 +36622,7 @@ function readReviewLedger(runDir, storyId) {
     developerErroredWith,
     blockedWithNothingRun,
     reopened,
+    asIs,
     fixRound,
     formatRetries,
     formatRefusal,
@@ -38835,6 +38854,7 @@ class BuildSession {
   outcomes = new Map;
   refusals = new Map;
   capDeaths = new Map;
+  asIsSettlements = new Map;
   epics = new EpicState;
   lines = [];
   counters = new ReviewCounters;
@@ -38917,6 +38937,10 @@ class BuildSession {
     const review = this.reviewWorkFor(planned);
     if (review !== null)
       return await this.prepareReview(planned, review);
+    const asIs = this.asIsFor(planned);
+    if (asIs !== null) {
+      return refusedOnSequence(this.ctx, `${planned.story.id} was reopened \`--as-is\` by ${asIs.actor} (${asIs.note}) — the branch is to be ` + "settled as it stands, and `--prepare` dispatches a developer. `tldrx next` (headless) runs the " + "dod, the review and the merge over it; to build it with a developer instead, " + `\`tldrx story reopen ${planned.story.id} --note "…"\` replaces the signature.`);
+    }
     let fixlist;
     try {
       fixlist = this.fixlistFor(planned.story.id);
@@ -39225,10 +39249,88 @@ class BuildSession {
       throw rejected.reason;
     return halves;
   }
+  asIsFor(planned) {
+    return readReviewLedger(this.ctx.runDir, planned.story.id).asIs;
+  }
+  async asIsHalf(planned, asIs) {
+    const id = planned.story.id;
+    const before = this.statusOf(planned);
+    this.refusals.delete(id);
+    this.capDeaths.delete(id);
+    this.asIsSettlements.set(id, asIs);
+    const story = await this.writes.run(() => this.openStory(planned));
+    await this.writes.run(() => {
+      this.ctx.emit("task.started", {
+        phase: this.ctx.phaseId,
+        story: id,
+        wave: planned.wave,
+        repo: planned.story.repo,
+        branch: story.branch,
+        attempt: story.attempt,
+        as_is: true
+      });
+      this.setStoryStatus(planned, "in_progress");
+    });
+    this.lines.push(`  · ${id}: settling \`${story.branch}\` as it stands — signed by ${asIs.actor}: ${asIs.note}`);
+    const install = await this.installDeps(story);
+    if (install !== null && installFailed(install)) {
+      return {
+        story,
+        cost: 0,
+        dod: [],
+        commit: null,
+        failure: installFailureReason(install, planned.story.repo),
+        developerError: null,
+        before
+      };
+    }
+    const ahead = await commitsBetween(story.repoDir, story.epicBranch, story.branch);
+    if (ahead === null || ahead === 0) {
+      return {
+        story,
+        cost: 0,
+        dod: [],
+        commit: null,
+        failure: asIsNotAheadReason(story.branch, story.epicBranch, ahead),
+        developerError: null,
+        before
+      };
+    }
+    const dod = await this.runDod(story);
+    if (!this.dodProves(dod)) {
+      const failing = dodFailure(dod);
+      return {
+        story,
+        cost: 0,
+        dod,
+        commit: null,
+        failure: failing === undefined ? "the story declares no dod commands, so nothing could prove it" : dodFailureReason(failing, planned.story.repo),
+        developerError: null,
+        before
+      };
+    }
+    const commit2 = await headSha(story.worktree);
+    if (commit2 === "") {
+      return {
+        story,
+        cost: 0,
+        dod,
+        commit: null,
+        failure: `\`${story.branch}\` has no HEAD to take — git could not resolve it`,
+        developerError: null,
+        before
+      };
+    }
+    return { story, cost: 0, dod, commit: commit2, failure: null, developerError: null, before };
+  }
   async buildHalf(planned) {
+    const asIs = this.asIsFor(planned);
+    if (asIs !== null)
+      return await this.asIsHalf(planned, asIs);
     const before = this.statusOf(planned);
     this.refusals.delete(planned.story.id);
     this.capDeaths.delete(planned.story.id);
+    this.asIsSettlements.delete(planned.story.id);
     const story = await this.writes.run(() => this.openStory(planned, true));
     await this.writes.run(() => {
       this.ctx.emit("task.started", {
@@ -40168,6 +40270,7 @@ class BuildSession {
       reason: parts.reason,
       permissionRefused: this.refusals.get(id) ?? null,
       budgetDeath: this.capDeaths.get(id) ?? null,
+      asIs: this.asIsSettlements.get(id) ?? null,
       rescued,
       cost_usd: parts.cost
     };
@@ -40198,12 +40301,13 @@ class BuildSession {
       attempt: story.attempt,
       ...parts.epicBase === null || parts.epicBase === undefined || parts.epicBase === "" ? {} : { epic_base: parts.epicBase },
       ...outcome.permissionRefused == null ? {} : { permission_refused: outcome.permissionRefused },
-      ...outcome.budgetDeath == null ? {} : { budget_death: outcome.budgetDeath }
+      ...outcome.budgetDeath == null ? {} : { budget_death: outcome.budgetDeath },
+      ...outcome.asIs == null ? {} : { as_is: true, as_is_by: outcome.asIs.actor, as_is_note: outcome.asIs.note }
     });
     if (pruning && (rescued === null || rescued.worktree === null)) {
       await removeWorktree(story.repoDir, story.worktree);
     }
-    this.lines.push(`  ${status === "done" ? "✓" : "·"} ${id} → \`${status}\`` + (outcome.reason === null ? "" : ` (${outcome.reason})`) + (outcome.permissionRefused == null ? "" : ` — ${withCure(`\`${outcome.permissionRefused}\` was refused for approval; the tree held committed work, so the DoD decided`, outcome.permissionRefused)}`));
+    this.lines.push(`  ${status === "done" ? "✓" : "·"} ${id} → \`${status}\`` + (outcome.reason === null ? "" : ` (${outcome.reason})`) + (outcome.asIs == null ? "" : ` — ${AS_IS_MARK}; ${outcome.asIs.actor} signed it`) + (outcome.permissionRefused == null ? "" : ` — ${withCure(`\`${outcome.permissionRefused}\` was refused for approval; the tree held committed work, so the DoD decided`, outcome.permissionRefused)}`));
   }
   writeLog(outcome) {
     const dir = join100(this.ctx.runDir, BUILD_PHASE, LOG_DIR);
@@ -48330,8 +48434,13 @@ function reopenStory(options) {
     return refuse4(['story reopen needs a story id: `tldrx story reopen S3 --note "why"`']);
   }
   const forFix = options.forFix === true;
+  const asIs = options.asIs === true;
   if (options.note.trim() === "") {
-    return forFix ? refuse4([
+    return asIs ? refuse4([
+      `story reopen --as-is needs --note: \`tldrx story reopen ${id} --as-is --note "<what you did by hand>"\``,
+      "  the note is the ONLY record of who finished this branch and how — no developer will run,",
+      "  so nothing else in the log will say where the commits came from"
+    ]) : forFix ? refuse4([
       `story reopen --for-fix needs --note: \`tldrx story reopen ${id} --for-fix --note "<the defect>"\``,
       "  the note IS the defect — it is what scopes the fix round, and what the reviewer reads",
       "  to tell a fix from a second opinion about the story"
@@ -48425,7 +48534,7 @@ function reopenStory(options) {
     }
     throw error;
   }
-  const event7 = reopenEvent(options, store.runId, id, row2.wave, row2.status, ledger4.verdicts, forFix);
+  const event7 = reopenEvent(options, store.runId, id, row2.wave, row2.status, ledger4.verdicts, forFix, asIs);
   const validation = validateEvent(event7);
   if (!validation.ok) {
     const first2 = validation.issues[0];
@@ -48456,6 +48565,19 @@ function reopenStory(options) {
       ]
     };
   }
+  if (asIs) {
+    return {
+      code: EXIT_OK12,
+      lines: [
+        `reopened ${id} in ${store.runId} — \`${row2.status}\` → \`${REOPENED_TO}\` (${row2.wave}), ` + "to be settled from its branch AS IT STANDS",
+        `  signed by ${options.actor}: ${options.note}`,
+        "  no developer will be spawned: the next Build turn runs the dod, the review and the merge " + "over the commits already on the story branch",
+        "  it is not a shortcut past either gate — a red dod BLOCKS the story, and so does a branch " + "that carries no commit its epic has not already got; the refusal says which",
+        "  the record will say the branch was taken as it stands and name you, so nothing reads as " + "though a developer delivered it",
+        ...kept
+      ]
+    };
+  }
   return {
     code: EXIT_OK12,
     lines: [
@@ -48481,7 +48603,7 @@ function nextStep(runId, stage2) {
 function buildStage(store) {
   return store.run.phases.find((phase) => phase.id === BUILD_PHASE2)?.stages[0];
 }
-function reopenEvent(options, runId, storyId, wave, from, verdicts, forFix) {
+function reopenEvent(options, runId, storyId, wave, from, verdicts, forFix, asIs) {
   return {
     ts: options.at,
     run: runId,
@@ -48496,7 +48618,7 @@ function reopenEvent(options, runId, storyId, wave, from, verdicts, forFix) {
       from_status: from,
       to_status: REOPENED_TO,
       verdicts,
-      reason: forFix ? "fix" : "attempts",
+      reason: forFix ? "fix" : asIs ? "as_is" : "attempts",
       note: options.note
     }
   };
@@ -48703,7 +48825,7 @@ var VALUE_FLAGS6 = ["run", "root", "note"];
 var storyCommand = {
   name: "story",
   summary: "Give one Build story another run of attempts, or widen the paths it declares",
-  usage: `tldrx story reopen <id> --note <text> [--for-fix] [--run <id>] [--root <path>]
+  usage: `tldrx story reopen <id> --note <text> [--for-fix | --as-is] [--run <id>] [--root <path>]
 ` + "       tldrx story widen <id> <path>… --note <text> [--run <id>] [--root <path>]",
   implemented: true,
   async run(argv) {
@@ -48721,11 +48843,20 @@ ${storyCommand.usage}
 function storyReopen(argv) {
   try {
     const args = parseArgs(argv, VALUE_FLAGS6);
+    if (boolFlag(args, "for-fix") && boolFlag(args, "as-is")) {
+      process.stderr.write(`tldrx story reopen: --for-fix and --as-is answer different questions — nothing was written
+` + "  --for-fix opens a fix round on a `done` story: one named defect, landed by a developer.\n" + `  --as-is settles an UNFINISHED story from its branch as it stands, with no developer at all.
+` + `  Type the one you mean.
+` + `${storyCommand.usage}
+`);
+      return EXIT_USAGE;
+    }
     const outcome = reopenStory({
       root: workspaceRootFrom(args),
       storyId: args.positionals[0] ?? "",
       note: stringFlag(args, "note") ?? "",
       forFix: boolFlag(args, "for-fix"),
+      asIs: boolFlag(args, "as-is"),
       runId: stringFlag(args, "run"),
       actor: currentActor(),
       at: nowRfc3339()
@@ -48745,6 +48876,12 @@ function storyReopen(argv) {
 function storyWiden(argv) {
   try {
     const args = parseArgs(argv, VALUE_FLAGS6);
+    if (boolFlag(args, "as-is")) {
+      process.stderr.write("tldrx story widen: --as-is is a flag of `reopen`, not of `widen` — nothing was written\n" + "  widening declares a path; `--as-is` settles a story from its branch as it stands.\n" + `  \`tldrx story reopen <id> --as-is --note "<what you did by hand>"\` is the verb you want.
+` + `${storyCommand.usage}
+`);
+      return EXIT_USAGE;
+    }
     if (boolFlag(args, "for-fix")) {
       process.stderr.write("tldrx story widen: --for-fix is a flag of `reopen`, not of `widen` — nothing was written\n" + "  widening declares a path; `--for-fix` reopens finished work for one named defect.\n" + `  \`tldrx story reopen <id> --for-fix --note "<the defect>"\` first, then widen the reopened story.
 ` + `${storyCommand.usage}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tldr-experts",
-  "version": "0.18.3",
+  "version": "0.19.0",
   "description": "tldr-experts: an evidence-first, file-based AI development framework - five stages, a gate on every one, and every claim cited or refused. Installs the `tldrx` (and `tldr-experts`) command. Beta.",
   "license": "MIT",
   "author": "Alan Martinez",

package/plugin/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$doc": "Shape verified from https://code.claude.com/docs/en/plugins.md (Quickstart > Create the plugin manifest). Fields used here: name, description, version, author.name. Only plugin.json goes inside .claude-plugin/; skills/, agents/ and hooks/ live at the plugin root.",
   "name": "tldrx",
   "description": "tldr-experts: an evidence-first, file-based AI development framework. Five stages, a gate on every one, every claim cited or refused. Beta.",
-  "version": "0.18.3",
+  "version": "0.19.0",
   "author": {
     "name": "Alan Martinez"
   }