@jwilger/pi-development-system 0.66.0 → 0.67.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.66.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/planning/intake-tool.ts

@@ -43,9 +43,44 @@ 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). The user choosing
- * "fix" is the explicit agreement, so it is recorded as a user-approved departure for this slice only.
+ * 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 },
@@ -60,7 +95,7 @@ async function fixWithoutReview(
     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",
+    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 },
@@ -112,19 +147,20 @@ 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 departed = sizing === "fix" ? await fixWithoutReview(deps, ctx, slice) : undefined;
+      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) });
-      const note =
-        departed === undefined
-          ? ""
-          : `\nRecorded in ${departed}: no review rounds for this fix (you sized it fix).`;
+      const note = waiverNote(sizing, departed);
       return reply(`${final}\nPhase: ${phaseFor(sizing)}. Active slice: ${slice}.${note}`);
     },
   };

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) {