@jwilger/pi-development-system 0.86.0 → 0.87.0

package/README.md

@@ -40,6 +40,10 @@ in `local-only` mode; CI is not awaited), and `devsys_finish_slice` closes it ex
 reason, abandons it. A plan's increments each end in a push, so each increment is its own slice: the
 next one starts with `devsys_intake`.
 
+`devsys_intake` does not interrupt autonomous work: Jev's size is used when Jev is at least 50%
+confident, and the user is asked to pick only when it is less sure (or unavailable). A size decided up
+front, such as in a goal's planning, is passed as `size` and skips the sizing question entirely (a `fix` still asks whether to waive review).
+
 With `codemode` enabled (`"defaultTools": ["+codemode"]` in pi settings), rarely used tools are
 reached through scripts and the `judge_*` Jev wrappers exist for scripts only; without codemode
 the rarely used tools are declared directly and the wrappers are absent.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.86.0",
+  "version": "0.87.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

@@ -9,4 +9,4 @@ Write the plan for the current work with the work-intake-and-slicing skill.
 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. 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: call `devsys_begin_work` (so the review and red-first gates are on while the increment is built; it does nothing if the work is already implementing). A push of a clean, reviewed tree closes the slice, so each later increment starts with `devsys_intake`. Then, 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. Only after the user approves the plan: call `devsys_begin_work` (so the review and red-first gates are on while the increment is built; it does nothing if the work is already implementing). A push of a clean, reviewed tree closes the slice, so each later increment starts with `devsys_intake`. Then, if a `create_goal` tool exists in this session, call it with the objective (name each increment's size in it, so every later `devsys_intake` passes `size` and nobody is asked to size it; a `fix` still asks the user whether to waive review) "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

@@ -5,7 +5,7 @@ argument-hint: "<what you want done>"
 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.
+2. Show the user the size and artifacts. Jev sizes the work and intake proceeds without asking when it is at least 50% confident; only a less confident Jev makes the tool ask the user to pick. If the size is already decided (say, in a goal's or plan's up-front planning), pass it as `size` and nobody is asked to size it (a `fix` still asks whether to waive review).
 3. Produce the planning artifacts first (brief, decision register, journeys, event model, architecture, lens review, in that order, whichever are recommended), then the task record. `review` and `adr-if-needed` are not written up front: review happens on the finished slice, and an ADR when a decision needs one. 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 `capability` and `product` the phase stays `planning` while you produce the artifacts and the plan. The single point where it changes is the user approving the whole plan: then call `devsys_begin_work` so the review and red-first gates switch on (it does nothing if already implementing).
-5. 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.
+5. For a `fix` the user is also asked (when a user is present) 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

@@ -16,7 +16,7 @@ Ask these in order and stop at the first yes:
 3. Does it change existing behaviour in one area? That is a `change`.
 4. Otherwise it is a `fix`.
 
-`/devsys-start` proposes a size with Jev and asks you to confirm. If you disagree, change it; the size is a judgement, not a rule.
+`/devsys-start` sizes the work with Jev and proceeds when Jev is at least 50% confident, saying so; below that it asks you to pick. If the size is already decided (a goal's planning, a plan's increment), pass it as `size` and nobody is asked to size it (a `fix` still asks whether to waive review). If you disagree with a size, change it; it is a judgement, not a rule.
 
 ## Artifacts follow size
 

package/src/context/status.ts

@@ -14,9 +14,8 @@ const ciLabel = (state: DevsysState): string | undefined => {
 };
 
 const activeReview = (state: DevsysState): string | undefined => {
-  // Without an active slice (before /devsys-start exists) show the most recent review instead of nothing.
-  const review =
-    state.activeSlice === undefined ? state.reviews?.at(-1) : reviewOf(state, state.activeSlice);
+  // No active slice, no review: a closed slice's last count would only mislead the next one.
+  const review = state.activeSlice === undefined ? undefined : reviewOf(state, state.activeSlice);
   return review === undefined ? undefined : reviewLabel(review);
 };
 

package/src/core/review-flow.ts

@@ -19,8 +19,9 @@ export const upsertReview = (state: DevsysState, review: ReviewState): DevsysSta
   return { ...state, reviews: [...others, review] };
 };
 
+/** Capped at the requirement: extra clean rounds (after a late change) are not progress past "done". */
 export const reviewLabel = (review: ReviewState): string =>
-  `review: ${cleanStreak(review)}/${review.required} clean`;
+  `review: ${Math.min(cleanStreak(review), review.required)}/${review.required} clean`;
 
 /**
  * Why a commit on this slice lacks a satisfied review, or `undefined` when the review is complete

package/src/planning/intake-tool.ts

@@ -13,13 +13,27 @@ 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";
+import {
+  decideSize,
+  phaseFor,
+  proposeArtifacts,
+  renderProposal,
+  type SizeDecision,
+  sliceSlug,
+  uniqueSlice,
+} from "./intake.ts";
 
 const Parameters = Type.Object({
   request: Type.String({ description: "What the user asked for, in their words." }),
   repoSummary: Type.Optional(
     Type.String({ description: "One or two sentences on the repository, if known." }),
   ),
+  size: Type.Optional(
+    Type.String({
+      description:
+        "fix, change, capability or product, when the size is already decided (for example during a goal's up-front planning). Skips Jev's sizing question and the user's.",
+    }),
+  ),
 });
 
 const SIZES: readonly Sizing[] = ["fix", "change", "capability", "product"];
@@ -62,6 +76,9 @@ async function declinedToReplace(
   const { activeSlice, phase } = before;
   const inFlight = phase === "implementing" || phase === "reviewing" || phase === "delivering";
   if (activeSlice === undefined || !inFlight) return undefined;
+  if (!ctx.hasUI) {
+    return `Slice "${activeSlice}" is still ${phase}; replacing it needs the user's yes, and there is no UI to ask. Intake cancelled; slice "${activeSlice}" is unchanged.`;
+  }
   const go = await ctx.ui.confirm(
     "Slice already in flight",
     `Slice "${activeSlice}" is still ${phase}. Its uncommitted or unpushed changes would ship under the new slice's rules. Start new work anyway?`,
@@ -69,6 +86,28 @@ async function declinedToReplace(
   return go ? undefined : `Intake cancelled; slice "${activeSlice}" is unchanged.`;
 }
 
+type Chosen = { readonly sizing: Sizing } | { readonly stop: string; readonly isError: boolean };
+
+/** A decided size passes through; an undecided one asks the user (headless: stops with the proposal). */
+async function chooseSize(
+  ctx: ExtensionContext,
+  decision: SizeDecision,
+  proposalFor: (size: Sizing) => ReturnType<typeof proposeArtifacts>,
+): Promise<Chosen> {
+  if (decision.kind === "decided") return { sizing: decision.size };
+  const { basis, proposed } = decision;
+  const proposal = renderProposal({ sizing: proposed, basis, proposal: proposalFor(proposed) });
+  if (!ctx.hasUI) {
+    return { stop: `${proposal}\nHeadless: proposal only, not applied.`, isError: false };
+  }
+  const picked = await ctx.ui.select(`Size this work (${basis})`, sizeChoices(proposed));
+  if (picked === undefined) {
+    return { stop: `${proposal}\nIntake cancelled; nothing changed.`, isError: false };
+  }
+  const parsed = parseSizing(picked);
+  return isParseError(parsed) ? { stop: parsed.message, isError: true } : { sizing: parsed };
+}
+
 const waiverNote = (sizing: Sizing, departed: string | undefined): string => {
   if (departed !== undefined)
     return `\nRecorded in ${departed}: you waived fresh-context review for this fix.`;
@@ -108,7 +147,7 @@ async function fixWithoutReview(
   return path;
 }
 
-/** `devsys_intake`: Jev proposes a size and artifact set; the user confirms; state moves to the first phase. */
+/** `devsys_intake`: Jev (or the caller) sizes the work; only a doubtful Jev asks the user; state moves to the first phase. */
 export function createIntakeTool(deps: {
   pi: ExtensionAPI;
   state: SessionState;
@@ -119,36 +158,39 @@ export function createIntakeTool(deps: {
     label: "Start work",
     description:
       "Size a request (fix, change, capability, product) and list the planning artifacts that size needs. " +
-      "The user confirms the size; then phase, sizing and the active slice are set. Call at the start of any non-trivial work.",
+      "Jev sizes the work and the user is asked only when Jev is under 50% confident; pass `size` when it is already decided. Then phase, sizing and the active slice are set. Call at the start of any non-trivial work.",
     promptSnippet: "Size new work and propose the planning artifacts it needs",
     parameters: Parameters,
     exposure: "model-only",
     async execute(_id, params: Static<typeof Parameters>, _signal, _onUpdate, ctx) {
       const request = params.request.trim();
       if (request === "") return reply("request must not be empty", true);
-      const judged = await judgeSizing(deps.jev(ctx), {
-        request,
-        repoSummary: params.repoSummary ?? "",
-      });
-      const proposedSize: Sizing = judged.ok ? judged.value.sizing : "change";
-      const basis = judged.ok
-        ? `Jev judged ${judged.value.sizing} (confidence ${judged.value.confidence.toFixed(2)}).`
-        : `Jev unavailable (${judged.error.kind}); defaulted to change.`;
-      const artifactNeed = judged.ok ? judged.value.artifactNeed : {};
+      const given = params.size === undefined ? undefined : parseSizing(params.size.trim());
+      if (given !== undefined && isParseError(given)) return reply(given.message, true);
+      const judged =
+        given === undefined
+          ? await judgeSizing(deps.jev(ctx), { request, repoSummary: params.repoSummary ?? "" })
+          : undefined;
+      const decision = decideSize(
+        given,
+        judged?.ok ? judged.value : undefined,
+        judged?.ok === false ? judged.error.kind : "not asked",
+      );
+      const artifactNeed = judged?.ok ? judged.value.artifactNeed : {};
       const proposalFor = (size: Sizing) => proposeArtifacts(size, artifactNeed);
-      const proposal = renderProposal({
-        sizing: proposedSize,
-        basis,
-        proposal: proposalFor(proposedSize),
-      });
-      if (!ctx.hasUI) return reply(`${proposal}\nHeadless: proposal only, not applied.`);
-      const picked = await ctx.ui.select(`Size this work (${basis})`, sizeChoices(proposedSize));
-      if (picked === undefined) return reply(`${proposal}\nIntake cancelled; nothing changed.`);
-      const sizing = parseSizing(picked);
-      if (isParseError(sizing)) return reply(sizing.message, true);
+      const chosen = await chooseSize(ctx, decision, proposalFor);
+      if ("stop" in chosen) return reply(chosen.stop, chosen.isError);
+      const { sizing } = chosen;
       const before = deps.state.get();
       const keep = await declinedToReplace(ctx, before);
-      if (keep !== undefined) return reply(`${proposal}\n${keep}`);
+      if (keep !== undefined) {
+        const proposal = renderProposal({
+          sizing,
+          basis: decision.basis,
+          proposal: proposalFor(sizing),
+        });
+        return reply(`${proposal}\n${keep}`);
+      }
       const slice = uniqueSlice(sliceSlug(request), slicesInUse(before)) as SliceRef;
       deps.state.update((s) => ({
         ...s,
@@ -156,9 +198,14 @@ export function createIntakeTool(deps: {
         sizing,
         activeSlice: slice,
       }));
-      const waived = sizing === "fix" ? await askToWaiveReview(ctx, request, slice) : false;
+      const waived =
+        sizing === "fix" && ctx.hasUI ? await askToWaiveReview(ctx, request, slice) : false;
       const departed = waived ? await fixWithoutReview(deps, ctx, slice) : undefined;
-      const final = renderProposal({ sizing, basis, proposal: proposalFor(sizing) });
+      const final = renderProposal({
+        sizing,
+        basis: decision.basis,
+        proposal: proposalFor(sizing),
+      });
       const note = waiverNote(sizing, departed);
       return reply(`${final}\nPhase: ${phaseFor(sizing)}. Active slice: ${slice}.${note}`);
     },

package/src/planning/intake.ts

@@ -71,3 +71,36 @@ export const renderProposal = (input: {
   );
   return lines.join("\n");
 };
+
+/** Jev confidence below this asks the human; at or above it intake proceeds with Jev's size. */
+const ASK_BELOW = 0.5;
+
+export type SizeDecision =
+  | { readonly kind: "decided"; readonly size: Sizing; readonly basis: string }
+  | { readonly kind: "ask"; readonly proposed: Sizing; readonly basis: string };
+
+/**
+ * Pure: who sizes the work. A size given up front (the caller, e.g. a goal's planning, already
+ * decided) wins; otherwise Jev decides when it is confident enough; only a doubtful or missing
+ * judgement asks the human, with Jev's size (or `change`) as the proposal.
+ */
+export function decideSize(
+  given: Sizing | undefined,
+  judged: { readonly sizing: Sizing; readonly confidence: number } | undefined,
+  unavailable: string,
+): SizeDecision {
+  if (given !== undefined) {
+    return { kind: "decided", size: given, basis: `Size given up front: ${given}.` };
+  }
+  if (judged === undefined) {
+    return {
+      kind: "ask",
+      proposed: "change",
+      basis: `Jev unavailable (${unavailable}); defaulted to change.`,
+    };
+  }
+  const said = `Jev judged ${judged.sizing} (confidence ${judged.confidence.toFixed(2)})`;
+  return judged.confidence >= ASK_BELOW
+    ? { kind: "decided", size: judged.sizing, basis: `${said}; proceeding without asking.` }
+    : { kind: "ask", proposed: judged.sizing, basis: `${said}, too unsure to proceed alone.` };
+}