@jwilger/pi-development-system 0.64.0 → 0.66.0

package/extensions/development-system.ts

@@ -141,7 +141,7 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
   pi.registerTool(createRequestApprovalTool({ pi, approvals }));
   pi.registerTool(createModelsTool());
   pi.registerTool(createRouteTaskTool({ jev: (ctx) => jevHolder.forContext(ctx) }));
-  pi.registerTool(createIntakeTool({ state, jev: (ctx) => jevHolder.forContext(ctx) }));
+  pi.registerTool(createIntakeTool({ pi, state, jev: (ctx) => jevHolder.forContext(ctx) }));
   pi.registerTool(createTaskCheckTool({ jev: (ctx) => jevHolder.forContext(ctx) }));
   pi.registerTool(createWorkItemTool({ exec }));
   const reviewDeps = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.64.0",
+  "version": "0.66.0",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"

package/src/planning/intake-tool.ts

@@ -1,9 +1,17 @@
-import type { ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
+import { parseDeparture } from "../core/departure.ts";
+import { lookupGate } from "../core/gates.ts";
 import { parseSizing } from "../core/sizing.ts";
 import { type DevsysState, isParseError, type Sizing, type SliceRef } from "../core/types.ts";
+import { DEPARTURE_ENTRY_TYPE } from "../gates/record-departure-tool.ts";
 import type { Jev } from "../jev/client.ts";
 import { judgeSizing } from "../jev/questions/sizing.ts";
+import { appendDecision } from "../state/decision-log.ts";
 import type { SessionState } from "../state/session-state.ts";
 import { phaseFor, proposeArtifacts, renderProposal, sliceSlug, uniqueSlice } from "./intake.ts";
 
@@ -35,8 +43,40 @@ const slicesInUse = (state: DevsysState): Set<string> =>
     ...state.openDepartures.flatMap((d) => (d.scope.kind === "slice" ? [d.scope.slice] : [])),
   ]);
 
+/**
+ * I8.1 sizes a fix without a review artifact, but the commit gate reviews every slice (I6.4). The user choosing
+ * "fix" is the explicit agreement, so it is recorded as a user-approved departure for this slice only.
+ */
+async function fixWithoutReview(
+  deps: { pi: ExtensionAPI; state: SessionState },
+  ctx: ExtensionContext,
+  slice: SliceRef,
+): Promise<string | undefined> {
+  const info = lookupGate("review.unsatisfied");
+  const at = new Date();
+  const departure = parseDeparture({
+    id: `dep-${at.getTime()}-intake`,
+    gate: "review.unsatisfied",
+    tier: "soft",
+    default: info?.default ?? "finish the fresh-context review before release",
+    chosen: "no review rounds for this slice",
+    why: "the user confirmed this work as a fix, which the sizing table plans without a review artifact",
+    costIfWrong: "a defect in a small change ships without a fresh-context look",
+    approver: "user",
+    scope: { kind: "slice", slice },
+    revisitWhen: "the fix turns out to touch more than its task record named",
+    recordedAt: at.toISOString().replace(/\.\d{3}Z$/, "Z"),
+  });
+  if (isParseError(departure)) return undefined;
+  const { path } = await appendDecision(ctx.cwd, departure, at);
+  deps.pi.appendEntry(DEPARTURE_ENTRY_TYPE, departure);
+  deps.state.update((s) => ({ ...s, openDepartures: [...s.openDepartures, departure] }));
+  return path;
+}
+
 /** `devsys_intake`: Jev proposes a size and artifact set; the user confirms; state moves to the first phase. */
 export function createIntakeTool(deps: {
+  pi: ExtensionAPI;
   state: SessionState;
   jev: (ctx: ExtensionContext) => Jev;
 }): ToolDefinition<typeof Parameters> {
@@ -79,8 +119,13 @@ export function createIntakeTool(deps: {
         sizing,
         activeSlice: slice,
       }));
+      const departed = sizing === "fix" ? await fixWithoutReview(deps, ctx, slice) : undefined;
       const final = renderProposal({ sizing, basis, proposal: proposalFor(sizing) });
-      return reply(`${final}\nPhase: ${phaseFor(sizing)}. Active slice: ${slice}.`);
+      const note =
+        departed === undefined
+          ? ""
+          : `\nRecorded in ${departed}: no review rounds for this fix (you sized it fix).`;
+      return reply(`${final}\nPhase: ${phaseFor(sizing)}. Active slice: ${slice}.${note}`);
     },
   };
 }

package/src/planning/task-record.ts

@@ -26,10 +26,10 @@ const SECTIONS = [
 ] as const;
 type Section = (typeof SECTIONS)[number];
 
-const HEADER = /^## (\S+) [—-] (.+)$/;
+const HEADER = /^## (\S+) [—-] (\S.*?)\s*$/;
 const SECTION_LINE = /^\*\*([^:*]+)(?::\*\*|\*\*:)\s*(.*)$/;
-/** Top-level list items only; indented sub-items belong to the step above them. */
-const STEP = /^(?:\d+[.)]|[-*])\s+(.*)$/;
+/** Top-level list items only (CommonMark allows up to three spaces of indent); deeper items belong to the step above. */
+const STEP = /^ {0,3}(?:\d+[.)]|[-*+])\s+(.*)$/;
 const STEPS_MIN = 3;
 const STEPS_MAX = 7;
 /** Words that stand in for a command or an observable result. */
@@ -88,7 +88,19 @@ function splitSections(lines: readonly string[]): Sections {
       found.set(name, current);
     } else current?.push(line);
   }
-  const text = new Map([...found].map(([name, body]) => [name, body.join("\n").trim()] as const));
+  // Leading indentation is kept so the first list item of a section is read like the others.
+  const text = new Map(
+    [...found].map(
+      ([name, body]) =>
+        [
+          name,
+          body
+            .join("\n")
+            .replace(/^\s*\n/, "")
+            .trimEnd(),
+        ] as const,
+    ),
+  );
   return { text, duplicates };
 }
 
@@ -131,9 +143,14 @@ const stripTicks = (text: string): string => {
 const stepsOf = (text: string): string[] => {
   const lines = text.split("\n");
   const fenced = fencedFlags(lines);
+  // The first item sets the list's indent; an item two or more columns deeper is nested under a step.
+  let base: number | undefined;
   return lines.flatMap((line, at) => {
     const item = fenced[at] === true ? undefined : STEP.exec(line)?.[1]?.trim();
-    return item === undefined || item === "" ? [] : [item];
+    if (item === undefined || item === "") return [];
+    const indent = line.length - line.trimStart().length;
+    base ??= indent;
+    return indent >= base + 2 ? [] : [item];
   });
 };
 
@@ -148,6 +165,7 @@ function concrete(name: "Run" | "Expected", text: string): string | undefined {
 }
 
 const get = (sections: ReadonlyMap<Section, string>, s: Section): string => sections.get(s) ?? "";
+const got = (sections: ReadonlyMap<Section, string>, s: Section): string => get(sections, s).trim();
 
 /** Every readiness problem in the sections, so the author fixes them in one pass. */
 function problemsOf(markdown: string, split: Sections): string[] {
@@ -156,7 +174,7 @@ function problemsOf(markdown: string, split: Sections): string[] {
   if (split.duplicates.length > 0) {
     problems.push(`duplicate section: ${[...new Set(split.duplicates)].join(", ")}`);
   }
-  const missing = SECTIONS.filter((s) => get(sections, s) === "");
+  const missing = SECTIONS.filter((s) => got(sections, s) === "");
   if (missing.length > 0) problems.push(`missing section: ${missing.join(", ")}`);
   if (/\bTBD\b/.test(markdown)) problems.push("contains TBD; decide it or split the task");
   const steps = stepsOf(get(sections, "Steps"));
@@ -164,7 +182,7 @@ function problemsOf(markdown: string, split: Sections): string[] {
     problems.push(`Steps must be ${STEPS_MIN}-${STEPS_MAX} steps, found ${steps.length}`);
   }
   for (const name of ["Run", "Expected"] as const) {
-    const why = missing.includes(name) ? undefined : concrete(name, get(sections, name));
+    const why = missing.includes(name) ? undefined : concrete(name, got(sections, name));
     if (why !== undefined) problems.push(why);
   }
   return problems;
@@ -202,9 +220,9 @@ export function parseTaskRecord(markdown: string, id?: string): TaskRecord | Par
   const found = locate(markdown.replace(/\r\n?/g, "\n"), id);
   if (isParseError(found)) return found;
   const split = splitSections(found.lines);
-  const problems = problemsOf(found.lines.join("\n"), split);
+  const problems = problemsOf(`${found.id} ${found.title}\n${found.lines.join("\n")}`, split);
   if (problems.length > 0) return parseError(problems.join("; "));
-  const text = (s: Section): string => get(split.text, s);
+  const text = (s: Section): string => got(split.text, s);
   return {
     id: found.id,
     title: found.title,
@@ -212,7 +230,7 @@ export function parseTaskRecord(markdown: string, id?: string): TaskRecord | Par
     files: filesOf(text("Files")),
     interfaces: text("Interfaces"),
     firstFailingTest: text("First failing test"),
-    steps: stepsOf(text("Steps")),
+    steps: stepsOf(get(split.text, "Steps")),
     run: stripTicks(text("Run")),
     expected: text("Expected"),
     outOfScope: text("Out of scope"),