@jwilger/pi-development-system 0.65.0 → 0.67.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.67.0",
   "description": "A pi extension package representing a seasoned approach to software development using a full AI SDLC.",
   "keywords": [
     "pi-package"

package/prompts/devsys-start.md

@@ -7,4 +7,4 @@ Start new work with the work-intake-and-slicing skill.
 1. Call `devsys_intake` with `request` set to: $ARGUMENTS (if empty, ask the user what they want done first).
 2. Show the user the proposed size and artifacts. The tool asks them to confirm or change the size.
 3. Follow the recommended artifacts in order. To skip one, call `devsys_record_departure` with gate `artifact.skipped:<artifact>` and the reason; do not skip silently. The event model and architecture are recommendations, never gates.
-4. For `fix` and `change` the phase is already `implementing`: write the task record, then work it test-first.
+4. For a confirmed `fix` the user is also asked whether to skip fresh-context review (it is logged if they say yes; if no, the slice needs its review rounds). For `fix` and `change` the phase is already `implementing`: write the task record, then work it test-first.

package/skills/work-intake-and-slicing/SKILL.md

@@ -20,7 +20,7 @@ Ask these in order and stop at the first yes:
 
 ## Artifacts follow size
 
-- `fix`: a task record.
+- `fix`: a task record. The user is asked separately whether to waive fresh-context review for it; a yes is logged as a user-approved `review.unsatisfied` departure for that slice, a no keeps the review gate.
 - `change`: task record, review, an ADR if a decision is hard to reverse.
 - `capability`: add a brief-lite, journeys, an event model, and optionally lens review.
 - `product`: the full set, including brief, decision register and architecture.

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,75 @@ const slicesInUse = (state: DevsysState): Set<string> =>
     ...state.openDepartures.flatMap((d) => (d.scope.kind === "slice" ? [d.scope.slice] : [])),
   ]);
 
+/** The waiver is its own question, naming the request and what the review gate actually covers. */
+const askToWaiveReview = (
+  ctx: ExtensionContext,
+  request: string,
+  slice: SliceRef,
+): Promise<boolean> =>
+  ctx.ui.confirm(
+    "Skip fresh-context review for this fix?",
+    `"${request.slice(0, 120)}"\nThe review gate checks the whole uncommitted diff, so yes waives review for everything committed under slice "${slice}". The waiver is logged in docs/decisions.`,
+  );
+
+/** Starting new work replaces the active slice; while it is in flight that needs the user's yes. */
+async function declinedToReplace(
+  ctx: ExtensionContext,
+  before: DevsysState,
+): Promise<string | undefined> {
+  const { activeSlice, phase } = before;
+  if (activeSlice === undefined || (phase !== "implementing" && phase !== "reviewing")) {
+    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?`,
+  );
+  return go ? undefined : `Intake cancelled; slice "${activeSlice}" is unchanged.`;
+}
+
+const waiverNote = (sizing: Sizing, departed: string | undefined): string => {
+  if (departed !== undefined)
+    return `\nRecorded in ${departed}: you waived fresh-context review for this fix.`;
+  return sizing === "fix"
+    ? "\nReview is NOT waived: this slice still needs its review rounds before commit."
+    : "";
+};
+
+/**
+ * I8.1 sizes a fix without a review artifact, but the commit gate reviews every slice (I6.4). Only the user's
+ * explicit yes to the waiver question is recorded, as a user-approved departure for this slice alone.
+ */
+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 was asked and agreed: this is 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> {
@@ -72,15 +147,21 @@ export function createIntakeTool(deps: {
       if (picked === undefined) return reply(`${proposal}\nIntake cancelled; nothing changed.`);
       const sizing = parseSizing(picked);
       if (isParseError(sizing)) return reply(sizing.message, true);
-      const slice = uniqueSlice(sliceSlug(request), slicesInUse(deps.state.get())) as SliceRef;
+      const before = deps.state.get();
+      const keep = await declinedToReplace(ctx, before);
+      if (keep !== undefined) return reply(`${proposal}\n${keep}`);
+      const slice = uniqueSlice(sliceSlug(request), slicesInUse(before)) as SliceRef;
       deps.state.update((s) => ({
         ...s,
         phase: phaseFor(sizing),
         sizing,
         activeSlice: slice,
       }));
+      const waived = sizing === "fix" ? await askToWaiveReview(ctx, request, slice) : false;
+      const departed = waived ? 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 = waiverNote(sizing, departed);
+      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+(.*)$/;

package/src/tracker/github.ts

@@ -226,9 +226,10 @@ const updateIssue = async (
   const current = toItem(raw.value);
   const hadMarker = (raw.value.labels ?? []).some((l) => isMarker(l.name));
   if (patch.status === "in-progress") {
-    // No --force: that would recolour the team's existing label. "Already exists" is success.
-    const made = await gh(["label", "create", IN_PROGRESS]);
-    if (!(made.ok || /already exists/i.test(made.error.message))) return made;
+    // No --force: that would recolour the team's existing label. Creating needs push rights, which someone who can
+    // only triage lacks even when the label exists, so a failed create is not fatal: the edit below fails if the
+    // label is really missing, and says so.
+    await gh(["label", "create", IN_PROGRESS]);
   }
   const flags = editFlags(current, hadMarker, patch);
   if (flags.length > 0) {