@jwilger/pi-development-system 0.65.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.65.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/gates/commit-guard.ts

@@ -125,10 +125,8 @@ async function reviewNeeds(
   ctx: ExtensionContext,
   command: string,
 ): Promise<Need[]> {
-  const { phase, activeSlice, sizing } = deps.state.get();
+  const { phase, activeSlice } = deps.state.get();
   if ((phase !== "implementing" && phase !== "reviewing") || activeSlice === undefined) return [];
-  // A fix is sized without a review artifact (I8.1); the gate must not demand rounds the size never asked for.
-  if (sizing === "fix") return [];
   const snap = await snapshotDiff(deps.exec, ctx.cwd, "HEAD");
   // An unreadable diff cannot be compared; the gate asks for a departure rather than guessing.
   const gap = reviewGap(

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,7 +26,7 @@ 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 (CommonMark allows up to three spaces of indent); deeper items belong to the step above. */
 const STEP = /^ {0,3}(?:\d+[.)]|[-*+])\s+(.*)$/;