@jwilger/pi-development-system 0.66.0 → 0.68.0

package/package.json

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

package/prompts/devsys-plan.md

@@ -8,5 +8,5 @@ Write the plan for the current work with the work-intake-and-slicing skill.
 2. Write `docs/plan/<slug>.md` with these sections: Goal and why; Constraints (what must not change); Increments, each shippable on its own and small enough to release, each with an **Acceptance** list (observable checks that say the increment is done) and a final Release step (commit, push, CI green, publish, update) followed by a STOP for the user; for every task a task record whose header is `## <id> — <title>` and whose sections are written exactly as `**Goal:**`, `**Files:**`, `**Interfaces:**`, `**First failing test:**`, `**Steps:**`, `**Run:**`, `**Expected:**`, `**Out of scope:**` (label and colon inside the bold, one section per label); a Progress checklist with one box per increment.
 3. Write each task so that someone who sees only that task could finish it. Never write `TBD`.
 4. Run `devsys_task_check` on every task record you wrote and fix each one until it says ready. Split any that come back too-big.
-5. If a `create_goal` tool exists in this session, call it with the objective "complete docs/plan/<slug>.md honouring its Constraints and Progress checklist, one increment at a time, stopping after each increment's Release step". Otherwise tell the user the plan path so they can start a goal on it. Do not depend on any goal tool's file format.
-6. Stop and ask the user to review the plan before any implementation starts.
+5. Stop and ask the user to review the plan before any implementation starts. Do not start a goal yet: a goal tool may continue on its own and begin implementing before the review.
+6. Only after the user approves the plan: if a `create_goal` tool exists in this session, call it with the objective "complete docs/plan/<slug>.md honouring its Constraints and Progress checklist, one increment at a time, stopping after each increment's Release step". Otherwise tell the user the plan path so they can start a goal on it. Do not depend on any goal tool's file format.

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/planning/task-check-tool.ts

@@ -29,6 +29,15 @@ const insideRepo = (cwd: string, target: string): boolean => {
   return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
 };
 
+/** Jev's aspect keys, named as the record's own sections so the author knows what to edit. */
+const SECTION_OF: Readonly<Record<string, string>> = {
+  goal: "Goal",
+  interfaces: "Interfaces",
+  firstFailingTest: "First failing test",
+  steps: "Steps",
+  check: "Run and Expected",
+};
+
 /** `devsys_task_check`: structural readiness is deterministic; Jev adds "specific enough" and "one task". */
 export function createTaskCheckTool(deps: {
   jev: (ctx: ExtensionContext) => Jev;
@@ -72,7 +81,8 @@ export function createTaskCheckTool(deps: {
           `${record.id}: too-big. Split it into task records that each need one failing test, then check each.`,
         );
       }
-      return reply(`${record.id}: needs-detail. Make these more specific: ${missing.join(", ")}.`);
+      const named = missing.map((m) => SECTION_OF[m] ?? m).join(", ");
+      return reply(`${record.id}: needs-detail. Make these more specific: ${named}.`);
     },
   };
 }

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