@jwilger/pi-development-system 0.76.0 → 0.78.0

package/README.md

@@ -13,6 +13,18 @@ and adds per-spawn `model` and `thinkingLevel`. **Remove the original from the
 entry), then `/reload`; otherwise both register `agent_spawn` and pi refuses the
 duplicate.
 
+## You do not need the slash commands
+
+Everything the system offers is reachable without remembering a command. Describe the work in
+plain words: when a prompt asks for new work, a fix or a review, the system adds a guideline
+naming the tool to use (`devsys_intake`, `devsys_review_start`). A `devsys` tool always shows
+what the current phase expects. When you say a slice is finished with no review round recorded,
+it tells you to start one. The slash commands (`/devsys-start`, `/devsys-plan`, `/devsys-review`)
+are shortcuts to the same tools.
+
+With `codemode` enabled (`"defaultTools": ["+codemode"]` in pi settings), rarely used tools and
+the `judge_*` Jev wrappers are reached through scripts; without it they are declared directly.
+
 ## Development
 
 ```sh

package/package.json

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

package/skills/strict-lints/SKILL.md

@@ -42,6 +42,11 @@ A warning is an error that has not been triaged yet. Before every commit:
   is made type-clean and lint-clean, dropped from the list, and removed from the
   `!src/subagents/...` exclusions in `biome.json`.
 
+## Running all the checks at once
+
+`references/verify.md` has a codemode script that runs the project's checks in parallel and
+returns `{tool, exit, firstFailures}` for each. Prefer it to five separate calls.
+
 ## What the extension does
 
 Editing a file so that it adds `#[allow(`, `#[expect(`, `// biome-ignore`,

package/skills/strict-lints/references/verify.md

@@ -0,0 +1,36 @@
+# Verify script (codemode)
+
+Run every check the project has in one go, in parallel, and get back only what failed.
+Paste this into the `codemode` tool. Each nested `bash` call still passes through the
+development-system guards, and the test-evidence tracker records each run, so a green result
+here is evidence a later "all checks pass" claim can rest on.
+
+Adjust `CHECKS` to the project profile (see the profile skill: TypeScript, Rust, ...).
+
+```js
+const CHECKS = [
+  { tool: "tsc", command: "npx tsc --noEmit" },
+  { tool: "biome", command: "biome check --error-on-warnings ." },
+  { tool: "tests", command: "npm test 2>&1 | tail -n 60" },
+];
+
+const results = await Promise.all(
+  CHECKS.map(async ({ tool, command }) => {
+    const r = await tools.bash({ command });
+    const lines = r.output.split("\n").filter((l) => l.trim() !== "");
+    return {
+      tool,
+      exit: r.exit_code,
+      firstFailures: r.exit_code === 0 ? [] : lines.slice(0, 15),
+    };
+  }),
+);
+
+return results;
+```
+
+Read the result before saying anything passed: every `exit` must be `0`. A non-zero `exit`
+means fix `firstFailures` first, then run the script again.
+
+Keep to checks that only read: a script may call any tool, and its nested calls are guarded
+like direct ones, but a verify script that edits files hides the edit inside one tool call.

package/src/context/turn-verifier.ts

@@ -5,6 +5,7 @@ import type {
   ToolResultEvent,
 } from "@earendil-works/pi-coding-agent";
 import { redactSecrets } from "../core/redact.ts";
+import { reviewOf } from "../core/review-flow.ts";
 import { exitCodeOf, summarizeOutput } from "../core/test-runner.ts";
 import type { DevsysState, Phase } from "../core/types.ts";
 import type { Jev } from "../jev/client.ts";
@@ -58,6 +59,9 @@ export function asksUser(text: string): boolean {
   return QUESTION_END.test(lead) || (LIST_ITEM.test(last) && CHOICE_LEAD_IN.test(lead));
 }
 
+const hasReviewRound = (state: DevsysState, slice: DevsysState["activeSlice"] & string): boolean =>
+  (reviewOf(state, slice)?.rounds.length ?? 0) > 0;
+
 /** True when a scope.expansion departure already covers the slice: the remedy the note asks for exists. */
 const expansionRecorded = (state: DevsysState, slice: string): boolean =>
   state.openDepartures.some(
@@ -72,6 +76,9 @@ const claimMessage = (): string =>
 const driftMessage = (slice: string): string =>
   `Development system: your last message describes work beyond the active slice "${slice}". Either return to the slice, or call devsys_record_departure (gate scope.expansion) to record why the scope is growing.`;
 
+const reviewMessage = (slice: string): string =>
+  `Development system: your last message calls the slice "${slice}" finished, but no review round has been recorded for it. Call devsys_review_start for a fresh-context review before committing.`;
+
 const TARGET_MAX = 120;
 
 const note = (content: string) => ({
@@ -107,7 +114,7 @@ function evidenceOf(event: ToolResultEvent): ToolEvidence {
 
 /** The corrective notes a judged turn earns: an unverified claim, and drift not yet covered by a departure. */
 function correctionsFor(
-  judged: { unverifiedClaim: number; driftFromSlice: number },
+  judged: { unverifiedClaim: number; driftFromSlice: number; sliceDone: number },
   state: DevsysState,
 ) {
   const slice = state.activeSlice;
@@ -118,6 +125,11 @@ function correctionsFor(
   return [
     ...(judged.unverifiedClaim >= VERIFIER_THRESHOLD ? [note(claimMessage())] : []),
     ...(drifted && slice !== undefined ? [note(driftMessage(slice))] : []),
+    ...(slice !== undefined &&
+    judged.sliceDone >= VERIFIER_THRESHOLD &&
+    !hasReviewRound(state, slice)
+      ? [note(reviewMessage(slice))]
+      : []),
   ];
 }
 
@@ -163,6 +175,10 @@ export function registerTurnVerifier(deps: TurnVerifierDeps): void {
       assistantText: parts.text,
       toolEvidence: evidence,
       ...(state.activeSlice === undefined ? {} : { activeSlice: state.activeSlice }),
+      checkDone:
+        state.phase === "implementing" &&
+        state.activeSlice !== undefined &&
+        !hasReviewRound(state, state.activeSlice),
     });
     if (!judged.ok) return undefined;
     const entries = correctionsFor(judged.value, state);

package/src/jev/questions/turn.ts

@@ -24,13 +24,31 @@ export const DRIFT_QUESTION: ClassifierBoolQuestion = {
   },
 };
 
+export const DONE_QUESTION: ClassifierBoolQuestion = {
+  type: "bool",
+  instructions:
+    "`activeSlice` names the one slice of work the agent is doing. Does `assistantText` say that the slice's work is finished and ready to commit or hand over, rather than reporting progress, planning more work or asking something?",
+  criteria: {
+    true: "The message presents the slice as complete: implemented, tested and ready to commit, push or review",
+    false:
+      "The message reports partial progress, plans next steps, asks a question or is unrelated to finishing the slice",
+  },
+};
+
 export type ToolEvidence = { tool: string; summary: string; exitCode?: number };
 export type TurnInput = {
   assistantText: string;
   toolEvidence: readonly ToolEvidence[];
   activeSlice?: string;
+  /** Also ask whether the message calls the slice finished (only meaningful with an active slice). */
+  checkDone?: boolean;
+};
+export type TurnJudgement = {
+  unverifiedClaim: number;
+  driftFromSlice: number;
+  /** 0 unless `checkDone` was set and a slice is active. */
+  sliceDone: number;
 };
-export type TurnJudgement = { unverifiedClaim: number; driftFromSlice: number };
 
 const TEXT_MAX = 4000;
 const SUMMARY_MAX = 240;
@@ -54,7 +72,7 @@ const probability = (
     : err({ kind: "provider", message: `malformed ${name} answer` });
 };
 
-/** Two independent narrow questions; drift is only asked when a slice is active. */
+/** Narrow questions asked together; drift and done only when a slice is active (done only on request). */
 export async function judgeTurn(
   jev: Jev,
   input: TurnInput,
@@ -65,17 +83,23 @@ export async function judgeTurn(
     toolEvidence: input.toolEvidence.slice(-EVIDENCE_MAX).map(evidenceLine),
     ...(slice === undefined ? {} : { activeSlice: slice }),
   };
-  const asked = await jev.ask(
-    state,
-    slice === undefined
-      ? { claim: CLAIM_QUESTION }
-      : { claim: CLAIM_QUESTION, drift: DRIFT_QUESTION },
-  );
+  const wantDone = slice !== undefined && input.checkDone === true;
+  const asked = await jev.ask(state, {
+    claim: CLAIM_QUESTION,
+    ...(slice === undefined ? {} : { drift: DRIFT_QUESTION }),
+    ...(wantDone ? { done: DONE_QUESTION } : {}),
+  });
   if (!asked.ok) return asked;
   const claim = probability(asked.value.claim, "claim");
   if (!claim.ok) return claim;
-  if (slice === undefined) return ok({ unverifiedClaim: claim.value, driftFromSlice: 0 });
+  if (slice === undefined)
+    return ok({ unverifiedClaim: claim.value, driftFromSlice: 0, sliceDone: 0 });
   const drift = probability(asked.value.drift, "drift");
   if (!drift.ok) return drift;
-  return ok({ unverifiedClaim: claim.value, driftFromSlice: drift.value });
+  if (!wantDone) {
+    return ok({ unverifiedClaim: claim.value, driftFromSlice: drift.value, sliceDone: 0 });
+  }
+  const done = probability(asked.value.done, "done");
+  if (!done.ok) return done;
+  return ok({ unverifiedClaim: claim.value, driftFromSlice: drift.value, sliceDone: done.value });
 }