@jwilger/pi-development-system 0.83.0 → 0.85.0

package/src/jev/questions/architecture.ts

@@ -0,0 +1,43 @@
+import type { ClassifierBoolQuestion } from "@earendil-works/pi-ai";
+import { redactSecrets } from "../../core/redact.ts";
+import { err, ok, type Result } from "../../core/result.ts";
+import type { Jev, JevError } from "../client.ts";
+
+/** At or above this, a diff with no ADR in it is flagged (gate `adr.missing`). */
+export const ARCHITECTURE_THRESHOLD = 0.7;
+
+export type ArchitectureInput = { diffStat: string; diff: string };
+
+const DIFF_CLIP = 8000;
+
+export const ARCHITECTURE_QUESTION: ClassifierBoolQuestion = {
+  type: "bool",
+  instructions:
+    "Read `diffStat` and `diff`. Does this change make an architecture-shaping decision that is hard to reverse: a new module boundary or layer, a new runtime dependency, a persisted data format or schema, a public protocol or interface contract, or a change to how components communicate?",
+  criteria: {
+    true: "The diff introduces or changes a boundary, dependency, data format or protocol that later code will build on and that would be costly to undo",
+    false:
+      "The diff is a bug fix, local refactor, test, documentation, formatting or feature work inside existing boundaries that is easy to change later",
+  },
+};
+
+// Bound the text before redacting (redaction cost grows with run length); keep margin so a secret at the cut is still seen whole.
+const clip = (text: string, max: number): string =>
+  redactSecrets(text.slice(0, max * 2)).slice(0, max);
+
+/** The probability that the diff shapes the architecture. */
+export async function judgeArchitectureShaping(
+  jev: Jev,
+  input: ArchitectureInput,
+): Promise<Result<number, JevError>> {
+  const asked = await jev.ask(
+    { diffStat: clip(input.diffStat, 2000), diff: clip(input.diff, DIFF_CLIP) },
+    { architecture: ARCHITECTURE_QUESTION },
+  );
+  if (!asked.ok) return asked;
+  const answer = asked.value.architecture;
+  if (answer?.type !== "bool") {
+    return err({ kind: "provider", message: "missing architecture answer" });
+  }
+  return ok(answer.probability);
+}

package/src/jev/questions/product-lenses.ts

@@ -0,0 +1,64 @@
+import type { ClassifierBoolQuestion } from "@earendil-works/pi-ai";
+import { redactSecrets } from "../../core/redact.ts";
+import { err, ok, type Result } from "../../core/result.ts";
+import { PRODUCT_LENSES, type ProductLens } from "../../review/lens-review.ts";
+import type { Jev, JevError } from "../client.ts";
+
+const lensQuestion = (instructions: string, yes: string, no: string): ClassifierBoolQuestion => ({
+  type: "bool",
+  instructions,
+  criteria: { true: yes, false: no },
+});
+
+/** One narrow question per product lens: does this lens have something to say about the brief? */
+export const PRODUCT_LENS_QUESTIONS: Readonly<Record<ProductLens, ClassifierBoolQuestion>> = {
+  cagan: lensQuestion(
+    "Read the `brief`. Does it commit to building a product or feature while leaving a value, usability, feasibility or viability risk unnamed or untested? A trivial copy, rename or maintenance change carries no such risk.",
+    "It proposes something to build and names no test or evidence for at least one of those risks",
+    "The change is trivial, or the brief names its risks and a test or evidence for them",
+  ),
+  torres: lensQuestion(
+    "Read the `brief`. Does it claim what customers need or want without citing discovery evidence (interviews, observed behaviour, usage data)? A brief that makes no customer claim does not count.",
+    "It asserts customer needs, demand or behaviour with no discovery evidence cited",
+    "Customer claims are backed by cited evidence, or the brief makes no customer claim",
+  ),
+  pichler: lensQuestion(
+    "Read the `brief`. Does it lack a measurable goal or metric that ties the work to a product vision or strategy? A trivial copy, rename or maintenance change needs none.",
+    "It proposes substantial work with no measurable goal or metric tied to a vision",
+    "It names a measurable goal or metric, or the change is trivial",
+  ),
+  perri: lensQuestion(
+    "Read the `brief`. Does it define success as shipping features or deliverables rather than as a measurable change for customers or the business? A typo fix, rename, dependency upgrade or other maintenance change is not a product bet and always answers false.",
+    "A product bet whose success is framed as delivering a list of features or a launch date, with no outcome measure",
+    "Success is a measurable outcome, or the change is maintenance (typo, rename, upgrade, refactor)",
+  ),
+  rumelt: lensQuestion(
+    "Read the `brief`. Does it state goals or ambitions without a diagnosis of the real challenge, a guiding policy and coherent actions? A trivial copy, rename or maintenance change needs no strategy.",
+    "It lists goals, ambitions or features with no diagnosis of the challenge and no guiding policy",
+    "It diagnoses the challenge and sets a policy and actions, or the change is trivial",
+  ),
+};
+
+const BRIEF_CLIP = 8000;
+
+// Bound the text before redacting (redaction cost grows with run length); keep margin so a secret at the cut is still seen whole.
+const clip = (text: string, max: number): string =>
+  redactSecrets(text.slice(0, max * 2)).slice(0, max);
+
+/** Probability per product lens that it applies to the brief. */
+export async function judgeProductLenses(
+  jev: Jev,
+  input: { brief: string },
+): Promise<Result<Record<ProductLens, number>, JevError>> {
+  const asked = await jev.ask({ brief: clip(input.brief, BRIEF_CLIP) }, PRODUCT_LENS_QUESTIONS);
+  if (!asked.ok) return asked;
+  const out = {} as Record<ProductLens, number>;
+  for (const lens of PRODUCT_LENSES) {
+    const answer = asked.value[lens];
+    if (answer?.type !== "bool" || !Number.isFinite(answer.probability)) {
+      return err({ kind: "provider", message: `missing or malformed answer for lens ${lens}` });
+    }
+    out[lens] = answer.probability;
+  }
+  return ok(out);
+}

package/src/jev/questions/solution-detail.ts

@@ -0,0 +1,43 @@
+import type { ClassifierBoolQuestion } from "@earendil-works/pi-ai";
+import { redactSecrets } from "../../core/redact.ts";
+import { err, ok, type Result } from "../../core/result.ts";
+import type { Jev, JevError } from "../client.ts";
+
+/** At or above this, the brief is reported as carrying solution-level detail (a warning only). */
+export const SOLUTION_DETAIL_THRESHOLD = 0.7;
+
+export type SolutionDetailInput = { brief: string };
+
+const BRIEF_CLIP = 8000;
+
+export const SOLUTION_DETAIL_QUESTION: ClassifierBoolQuestion = {
+  type: "bool",
+  instructions:
+    "Read `brief`, a product brief. Does it specify the solution rather than the problem: named database tables or columns, API endpoints, class or module names, framework or library choices, or step-by-step implementation design?",
+  criteria: {
+    true: "The brief prescribes how the system is built (tables, endpoints, classes, libraries, internal design) instead of, or in addition to, the outcome, users and risks",
+    false:
+      "The brief describes outcomes, users, journeys, constraints and risks in product terms; any technical mention is a stated constraint or a name the users themselves use",
+  },
+};
+
+// Bound the text before redacting (redaction cost grows with run length); keep margin so a secret at the cut is still seen whole.
+const clip = (text: string, max: number): string =>
+  redactSecrets(text.slice(0, max * 2)).slice(0, max);
+
+/** The probability that the brief contains solution-level detail. */
+export async function judgeSolutionDetail(
+  jev: Jev,
+  input: SolutionDetailInput,
+): Promise<Result<number, JevError>> {
+  const asked = await jev.ask(
+    { brief: clip(input.brief, BRIEF_CLIP) },
+    { solution: SOLUTION_DETAIL_QUESTION },
+  );
+  if (!asked.ok) return asked;
+  const answer = asked.value.solution;
+  if (answer?.type !== "bool") {
+    return err({ kind: "provider", message: "missing solution-detail answer" });
+  }
+  return ok(answer.probability);
+}

package/src/planning/adr-tool.ts

@@ -0,0 +1,70 @@
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { adrFileName, nextAdrNumber, parseAdrTitle, renderAdr } from "./adr.ts";
+
+const Parameters = Type.Object({
+  title: Type.String({ description: "The decision, in a few words (one line)." }),
+});
+
+const ADR_DIR = "docs/adr";
+const TEMPLATE = "0000-template.md";
+
+const reply = (text: string, isError = false) => ({
+  content: [{ type: "text" as const, text }],
+  details: undefined,
+  isError,
+});
+
+const message = (e: unknown): string => (e instanceof Error ? e.message : String(e));
+
+/**
+ * `devsys_adr_new`: the next numbered ADR, filled from `docs/adr/0000-template.md`. Numbering and the
+ * file name are mechanical, so the model writes the decision and not the paperwork.
+ */
+export function createAdrNewTool(deps: { now: () => Date }): ToolDefinition<typeof Parameters> {
+  return {
+    name: "devsys_adr_new",
+    // pi runs a turn's tool calls in parallel; two calls would read the same directory and pick the same number.
+    executionMode: "sequential",
+    label: "New ADR",
+    description:
+      "Create the next numbered ADR in docs/adr from its template and return the path to fill in. Use for a hard-to-reverse technical decision (a boundary, dependency, data format or protocol); product decisions go in the decision register.",
+    promptSnippet: "Create the next ADR from the template",
+    parameters: Parameters,
+    async execute(_id, params: Static<typeof Parameters>, _signal, _onUpdate, ctx) {
+      const title = parseAdrTitle(params.title);
+      if (!title.ok) return reply(title.error.message, true);
+      const dir = join(ctx.cwd, ADR_DIR);
+      let template: string;
+      try {
+        template = await readFile(join(dir, TEMPLATE), "utf8");
+      } catch {
+        return reply(
+          `${ADR_DIR}/${TEMPLATE} is missing, so there is nothing to start from; add the template first.`,
+          true,
+        );
+      }
+      try {
+        const number = nextAdrNumber(await readdir(dir));
+        const name = adrFileName(number, title.value);
+        const date = deps.now().toISOString().slice(0, 10);
+        await mkdir(dir, { recursive: true });
+        // `wx`: fail rather than overwrite an ADR with the same file name (calls from other sessions).
+        await writeFile(
+          join(dir, name),
+          renderAdr(template, { number, title: title.value, date }),
+          {
+            flag: "wx",
+          },
+        );
+        return reply(
+          `Created ${ADR_DIR}/${name} (status proposed). Fill in Context, Decision, Consequences, Alternatives and Revisit when. Leave the status proposed until the user agrees, then set it to accepted.`,
+        );
+      } catch (e) {
+        return reply(`could not create the ADR: ${message(e)}`, true);
+      }
+    },
+  };
+}

package/src/planning/adr.ts

@@ -0,0 +1,46 @@
+import { err, ok, type Result } from "../core/result.ts";
+import { type ParseError, parseError } from "../core/types.ts";
+
+/** `0004-prompt-cache-safe-channels.md` → 4. The template is `0000` and the README has no number. */
+const NUMBERED = /^(\d{4})-.+\.md$/;
+
+/** One more than the highest ADR number present; gaps are not filled, so a number is never reused. */
+export function nextAdrNumber(fileNames: readonly string[]): number {
+  const numbers = fileNames.flatMap((name) => {
+    const digits = NUMBERED.exec(name)?.[1];
+    return digits === undefined ? [] : [Number.parseInt(digits, 10)];
+  });
+  return Math.max(0, ...numbers) + 1;
+}
+
+export const slugify = (title: string): string =>
+  title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+/** A one-line title with something to slug from; a line break could add lines to the document. */
+export function parseAdrTitle(input: string): Result<string, ParseError> {
+  const title = input.trim();
+  if (/[\r\n]/.test(title)) return err(parseError("an ADR title is a single line"));
+  if (slugify(title) === "") {
+    return err(parseError("an ADR title needs at least one letter or digit"));
+  }
+  return ok(title);
+}
+
+const adrNumberText = (n: number): string => String(n).padStart(4, "0");
+
+export const adrFileName = (n: number, title: string): string =>
+  `${adrNumberText(n)}-${slugify(title)}.md`;
+
+export type AdrInput = { number: number; title: string; date: string };
+
+/** The template with its heading, status and date filled in; the sections are left for the author. */
+export function renderAdr(template: string, input: AdrInput): string {
+  // Function replacers: a title is data, so `$&` and `$1` in it must not act as replacement patterns.
+  return template
+    .replace(/^# ADR NNNN: .*$/m, () => `# ADR ${adrNumberText(input.number)}: ${input.title}`)
+    .replace(/^- \*\*Status:\*\* .*$/m, () => "- **Status:** proposed")
+    .replace(/^- \*\*Date:\*\* .*$/m, () => `- **Date:** ${input.date}`);
+}

package/src/planning/brief-lint.ts

@@ -0,0 +1,71 @@
+/**
+ * Brief lint (plan I9.5): a brief states the outcome, the people and the risks; endpoints, tables and
+ * class names are solution detail that belongs in an ADR or the architecture. This is the
+ * deterministic half (regex markers); the Jev half lives in `src/jev/questions/solution-detail.ts`.
+ * Findings are warnings: a brief may legitimately quote a constraint that looks technical.
+ */
+
+type BriefFindingKind = "endpoint" | "table" | "class" | "path";
+
+export type BriefFinding = {
+  kind: BriefFindingKind;
+  /** 1-based line in the brief. */
+  line: number;
+  /** The text that matched. */
+  match: string;
+  message: string;
+};
+
+type Rule = { kind: BriefFindingKind; pattern: RegExp; what: string };
+
+const RULES: readonly Rule[] = [
+  {
+    kind: "endpoint",
+    pattern: /\b(?:GET|POST|PUT|PATCH|DELETE)\s+\/[\w\-/{}:.]+/g,
+    what: "an HTTP endpoint",
+  },
+  {
+    kind: "table",
+    pattern: /\bCREATE\s+TABLE\b|`\w+`\s+table\b|\btable\s+`\w+`/gi,
+    what: "a database table",
+  },
+  {
+    kind: "class",
+    pattern:
+      /\b(?:(?:class|interface)\s+[A-Z]\w+|[A-Z][a-z0-9]+(?:[A-Z][a-z0-9]+)*(?:Service|Repository|Controller|Gateway|Manager|Handler|Factory|Client))\b/g,
+    what: "a class or service name",
+  },
+  {
+    kind: "path",
+    pattern: /\b(?:src|lib|test|app|packages)\/[\w\-./]+\.\w+/g,
+    what: "a source file path",
+  },
+];
+
+const advice = (what: string): string =>
+  `${what} is solution detail; keep the brief to outcome, users and risks and record this in an ADR (devsys_adr_new) or the architecture notes`;
+
+/** The brief with fenced code blocks blanked, keeping line numbers: an example in a fence is quoted, not specified. */
+function withoutFences(text: string): string[] {
+  let inFence = false;
+  return text.split("\n").map((line) => {
+    if (/^\s*```/.test(line)) {
+      inFence = !inFence;
+      return "";
+    }
+    return inFence ? "" : line;
+  });
+}
+
+export function lintBrief(text: string): BriefFinding[] {
+  return withoutFences(text).flatMap((line, i) =>
+    RULES.flatMap((rule) =>
+      [...line.matchAll(rule.pattern)].map((m) => ({
+        kind: rule.kind,
+        line: i + 1,
+        match: m[0],
+        message: advice(rule.what),
+      })),
+    ),
+  );
+}

package/src/planning/intake-tool.ts

@@ -60,12 +60,11 @@ async function declinedToReplace(
   before: DevsysState,
 ): Promise<string | undefined> {
   const { activeSlice, phase } = before;
-  if (activeSlice === undefined || (phase !== "implementing" && phase !== "reviewing")) {
-    return undefined;
-  }
+  const inFlight = phase === "implementing" || phase === "reviewing" || phase === "delivering";
+  if (activeSlice === undefined || !inFlight) return undefined;
   const go = await ctx.ui.confirm(
     "Slice already in flight",
-    `Slice "${activeSlice}" is still ${phase}. Its uncommitted changes would be committed under the new slice's rules. Start new work anyway?`,
+    `Slice "${activeSlice}" is still ${phase}. Its uncommitted or unpushed changes would ship under the new slice's rules. Start new work anyway?`,
   );
   return go ? undefined : `Intake cancelled; slice "${activeSlice}" is unchanged.`;
 }

package/src/planning/slice-close.ts

@@ -0,0 +1,195 @@
+import {
+  type ExtensionAPI,
+  type ExtensionContext,
+  isBashToolResult,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { extractCommits } from "../core/commit-command.ts";
+import type { Exec } from "../core/exec.ts";
+import { closeSlice, reviewWaived } from "../core/lifecycle.ts";
+import { pushTargets } from "../core/push-command.ts";
+import { isSatisfied } from "../core/review.ts";
+import { reviewOf } from "../core/review-flow.ts";
+import type { DevsysState } from "../core/types.ts";
+import { loadConfig } from "../state/config.ts";
+import type { SessionState } from "../state/session-state.ts";
+
+const SLICE_ENTRY_TYPE = "devsys-slice";
+
+export type SliceCloseDeps = { pi: ExtensionAPI; state: SessionState; exec: Exec };
+
+const IN_FLIGHT = new Set<DevsysState["phase"]>(["implementing", "reviewing", "delivering"]);
+
+/** True when `git status` shows nothing to commit; `undefined` when git could not say. */
+async function treeIsClean(exec: Exec, cwd: string): Promise<boolean | undefined> {
+  const r = await exec("git", ["status", "--porcelain"], { cwd, timeout: 15_000 });
+  return r.code === 0 ? r.stdout.trim() === "" : undefined;
+}
+
+/** Commits on HEAD that no branch of `remote` has; works without an upstream, `undefined` when git could not say. */
+async function unpushedCommits(
+  exec: Exec,
+  cwd: string,
+  remote: string,
+): Promise<number | undefined> {
+  const r = await exec("git", ["rev-list", "--count", "HEAD", "--not", `--remotes=${remote}`], {
+    cwd,
+    timeout: 15_000,
+  });
+  const n = Number(r.stdout.trim());
+  return r.code === 0 && Number.isInteger(n) ? n : undefined;
+}
+
+/** No review is owed before this slice ships: its review is satisfied, or a departure waives it. */
+function reviewCleared(state: DevsysState): boolean {
+  if (state.activeSlice === undefined) return false;
+  const review = reviewOf(state, state.activeSlice);
+  return reviewWaived(state) || (review !== undefined && isSatisfied(review));
+}
+
+/** What delivered the slice: a commit when nothing leaves the machine, otherwise a push. */
+const shipped = (mode: string, command: string): boolean =>
+  mode === "local-only" ? extractCommits(command).length > 0 : pushTargets(command).length > 0;
+
+const closedMessage = (slice: string, how: string): string =>
+  `Slice ${slice} ${how}. Phase: idle; the next request starts new work with devsys_intake.`;
+
+/**
+ * Closes the slice when it ships: in any in-flight phase whose review is satisfied (`delivering`, or a session
+ * saved before the life cycle existed) or waived by a recorded departure, a successful push (trunk, pull-request) or commit (local-only) that
+ * leaves a clean working tree. CI is not awaited; the push guard already refuses to build on a red trunk.
+ */
+export function registerSliceClose(deps: SliceCloseDeps): void {
+  deps.pi.on("tool_result", async (event, ctx) => {
+    if (!isBashToolResult(event) || event.isError) return undefined;
+    const state = deps.state.get();
+    const { activeSlice, phase } = state;
+    if (activeSlice === undefined || !IN_FLIGHT.has(phase)) return undefined;
+    if (!reviewCleared(state)) return undefined;
+    const config = await loadConfig(ctx.cwd);
+    if (!(config.ok && shipped(config.value.delivery.mode, String(event.input.command)))) {
+      return undefined;
+    }
+    if ((await treeIsClean(deps.exec, ctx.cwd)) !== true) return undefined;
+    // A tags-only push, or a push of another branch, leaves this slice's commits where they were.
+    if (config.value.delivery.mode !== "local-only") {
+      if ((await unpushedCommits(deps.exec, ctx.cwd, config.value.delivery.remote)) !== 0)
+        return undefined;
+    }
+    // The checks above awaited git; close only the slice they were about.
+    if (deps.state.get().activeSlice !== activeSlice) return undefined;
+    deps.state.update(closeSlice);
+    deps.pi.sendMessage(
+      {
+        customType: SLICE_ENTRY_TYPE,
+        content: closedMessage(activeSlice, "was delivered"),
+        display: true,
+      },
+      { triggerTurn: false },
+    );
+    return undefined;
+  });
+}
+
+const Parameters = Type.Object({
+  abandon: Type.Optional(
+    Type.Boolean({
+      description:
+        "Close the slice without delivering it. Needs a reason; the working tree is left as it is.",
+    }),
+  ),
+  reason: Type.Optional(Type.String({ description: "Why the slice is abandoned (with abandon)." })),
+});
+
+const reply = (text: string, isError = false) => ({
+  content: [{ type: "text" as const, text }],
+  details: undefined,
+  isError,
+});
+
+/** Another slice became active while this one waited on the user or on git: leave it alone. */
+const changedMeanwhile = (slice: string) =>
+  reply(`Slice ${slice} is no longer the active slice; nothing was closed.`, true);
+
+/** Why a slice cannot be finished yet, or `undefined` when it is reviewed, clean and pushed. */
+async function finishBlocker(deps: Pick<SliceCloseDeps, "state" | "exec">, cwd: string) {
+  const state = deps.state.get();
+  const { activeSlice } = state;
+  if (activeSlice === undefined) return undefined;
+  if (!reviewCleared(state)) {
+    return `slice ${activeSlice} has no satisfied review: finish the review rounds (devsys_review_start), or record a review.unsatisfied departure`;
+  }
+  const clean = await treeIsClean(deps.exec, cwd);
+  if (clean !== true) {
+    return clean === false
+      ? "there are uncommitted changes: commit them first"
+      : "git could not report the working tree status";
+  }
+  const config = await loadConfig(cwd);
+  if (!config.ok) return `cannot read the delivery mode: ${config.error.message}`;
+  if (config.value.delivery.mode === "local-only") return undefined;
+  const ahead = await unpushedCommits(deps.exec, cwd, config.value.delivery.remote);
+  if (ahead === undefined) {
+    return "git could not say whether the commits are pushed";
+  }
+  return ahead > 0 ? `${ahead} commit(s) are not pushed yet: push first` : undefined;
+}
+
+/**
+ * `devsys_finish_slice`: the explicit way to close a slice. The push guard closes a delivered slice by itself;
+ * this covers what it cannot see (a push made outside pi, a slice that is dropped) and checks the same facts.
+ */
+export function createFinishSliceTool(
+  deps: Pick<SliceCloseDeps, "state" | "exec">,
+): ToolDefinition<typeof Parameters> {
+  return {
+    name: "devsys_finish_slice",
+    label: "Finish slice",
+    description:
+      "Close the active slice and return to idle. Checks that its review is satisfied (or waived by a recorded departure), the tree is clean and the commits are pushed. With abandon and a reason it drops the slice without delivering it, after the user confirms.",
+    promptSnippet: "Close the active slice once it is delivered, or abandon it",
+    parameters: Parameters,
+    exposure: "model-only",
+    async execute(
+      _id,
+      params: Static<typeof Parameters>,
+      _signal,
+      _onUpdate,
+      ctx: ExtensionContext,
+    ) {
+      const { activeSlice } = deps.state.get();
+      if (activeSlice === undefined) {
+        return reply("There is no active slice to finish. Start work with devsys_intake.", true);
+      }
+      if (params.abandon === true) {
+        const reason = params.reason?.trim() ?? "";
+        if (reason === "") return reply("abandoning a slice needs a reason: pass `reason`.", true);
+        // Idle switches the review and red-first gates off, so only the user may drop an unfinished slice.
+        if (!ctx.hasUI) {
+          return reply(
+            `Abandoning slice ${activeSlice} needs the user's confirmation and there is no interactive session; ask the user to run it.`,
+            true,
+          );
+        }
+        const go = await ctx.ui.confirm(
+          "Abandon slice?",
+          `Slice "${activeSlice}" would be closed without being delivered (${reason}). Its review and red-first gates stop applying; the working tree is left as it is.`,
+        );
+        if (!go) return reply(`Abandon declined; slice ${activeSlice} is unchanged.`, true);
+        if (deps.state.get().activeSlice !== activeSlice) return changedMeanwhile(activeSlice);
+        deps.state.update(closeSlice);
+        return reply(
+          `${closedMessage(activeSlice, `was abandoned (${reason})`)} The working tree was not touched.`,
+        );
+      }
+      const blocker = await finishBlocker(deps, ctx.cwd);
+      if (blocker !== undefined) {
+        return reply(`Slice ${activeSlice} is not finished: ${blocker}.`, true);
+      }
+      if (deps.state.get().activeSlice !== activeSlice) return changedMeanwhile(activeSlice);
+      deps.state.update(closeSlice);
+      return reply(closedMessage(activeSlice, "is finished"));
+    },
+  };
+}