@jwilger/pi-development-system 0.77.0 → 0.79.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/extensions/development-system.ts

@@ -8,7 +8,7 @@ import type {
 import { cadenceLine, DEFAULT_PUSH_MINUTES } from "../src/context/cadence.ts";
 import { appendContextTail, renderContextTail } from "../src/context/context-tail.ts";
 import { createPhaseTool } from "../src/context/devsys-tool.ts";
-import { applyIntentGuideline } from "../src/context/intent-trigger.ts";
+import { intentLineFor } from "../src/context/intent-trigger.ts";
 import { registerModelAdvice } from "../src/context/model-advice.ts";
 import { renderStatus, renderStatusLine, STATUS_KEY } from "../src/context/status.ts";
 import { applyPromptSection } from "../src/context/system-prompt.ts";
@@ -89,9 +89,15 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
   pi.on("session_start", (_event, ctx) => rebuild(ctx));
   pi.on("session_tree", (_event, ctx) => rebuild(ctx));
 
+  // The intent line rides in the context tail for this run only: a change to the system prompt
+  // would invalidate the provider's cache for the whole conversation.
+  let intentLine: string | undefined;
   pi.on("before_agent_start", async (event, ctx) => {
     applyPromptSection(event, state.get(), nonNegotiables);
-    await applyIntentGuideline(event, state.get(), jevHolder.forContext(ctx));
+    intentLine = await intentLineFor(event.prompt, state.get(), jevHolder.forContext(ctx));
+  });
+  pi.on("agent_end", () => {
+    intentLine = undefined;
   });
 
   pi.on("context", (event) => {
@@ -99,7 +105,7 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
     const cadence = cadenceLine(state.get(), now, pushMinutes);
     const messages = appendContextTail(
       event.messages,
-      renderContextTail(state.get(), cadence),
+      renderContextTail(state.get(), cadence, intentLine),
       now,
     );
     return messages === undefined ? undefined : { messages };
@@ -155,10 +161,13 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
     createRouteTaskTool({ jev: (ctx) => jevHolder.forContext(ctx) }),
     createTaskCheckTool({ jev: (ctx) => jevHolder.forContext(ctx) }),
     createWorkItemTool({ exec }),
-    ...createJudgeTools({ jev: (ctx) => jevHolder.forContext(ctx) }),
   ];
   for (const tool of rarelyUsed) pi.registerTool(tool);
   pi.on("session_start", () => declareWithoutCodemode(pi, rarelyUsed));
+  // The judge_* tools exist only for scripts: without codemode there is nothing to call them from.
+  for (const tool of createJudgeTools({ jev: (ctx) => jevHolder.forContext(ctx) })) {
+    pi.registerTool(tool);
+  }
   pi.registerTool(createPhaseTool({ state }));
   pi.registerTool(createBeginWorkTool({ state }));
   pi.registerTool(createIntakeTool({ pi, state, jev: (ctx) => jevHolder.forContext(ctx) }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.77.0",
+  "version": "0.79.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,41 @@
+# 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" },
+];
+
+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() !== "");
+    // Failure lines first: the head of a test run is mostly passing tests.
+    const failing = lines.filter((l) => /error|fail|✖|not ok/i.test(l));
+    return {
+      tool,
+      exit: r.exit_code,
+      firstFailures: r.exit_code === 0 ? [] : (failing.length > 0 ? failing : lines.slice(-15)).slice(0, 15),
+    };
+  }),
+);
+
+return results;
+```
+
+Never pipe a check through `tail`, `head` or `grep` inside `command`: the exit code is then the
+pipe's, not the check's, and a failing run reads as `0`. Trim the output in the script instead.
+
+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/context-tail.ts

@@ -9,15 +9,25 @@ const scopeLabel = (d: Departure): string =>
   d.scope.kind === "slice" ? `slice ${d.scope.slice}` : d.scope.kind;
 
 /** Small, cache-friendly reminder appended at the end of the context; undefined when nothing to say. */
-export function renderContextTail(state: DevsysState, cadence?: string): string | undefined {
-  if (state.phase === "idle" && state.openDepartures.length === 0) return undefined;
+export function renderContextTail(
+  state: DevsysState,
+  cadence?: string,
+  note?: string,
+): string | undefined {
+  if (state.phase === "idle" && state.openDepartures.length === 0 && note === undefined) {
+    return undefined;
+  }
   const head = [
     "[development-system]",
     `phase: ${state.phase} · slice: ${state.activeSlice ?? "none"}`,
     `Jev: ${state.jev}`,
     ...((state.profiles?.length ?? 0) > 0 ? [`profiles: ${state.profiles?.join(", ")}`] : []),
   ];
-  const tailLines = [...(cadence === undefined ? [] : [cadence]), REMINDER];
+  const tailLines = [
+    ...(note === undefined ? [] : [note]),
+    ...(cadence === undefined ? [] : [cadence]),
+    REMINDER,
+  ];
   const room = MAX_LINES - head.length - tailLines.length - 1;
   const lines = state.openDepartures.map(
     (d) => `- ${d.gate} — ${d.chosen.replace(/\s+/g, " ")} (${scopeLabel(d)})`,

package/src/context/intent-trigger.ts

@@ -1,4 +1,3 @@
-import type { BeforeAgentStartEvent } from "@earendil-works/pi-coding-agent";
 import type { DevsysState } from "../core/types.ts";
 import type { Jev } from "../jev/client.ts";
 import { type Intent, judgeIntent } from "../jev/questions/intent.ts";
@@ -6,38 +5,40 @@ import { type Intent, judgeIntent } from "../jev/questions/intent.ts";
 /** Probability at or above which an intent is acted on. */
 export const INTENT_AT = 0.7;
 
-/** Pure: the one guideline line an intent earns in a phase, or undefined. Questions and continuations earn none. */
+/**
+ * Pure: the one line an intent earns, or undefined. Only an idle session is nudged: inside a running
+ * slice a request cannot be told apart from an instruction for that slice, and a wrong nudge would
+ * restart intake. Questions and continuations never earn a line.
+ */
 export function intentGuideline(
   intent: Intent,
   confidence: number,
   phase: DevsysState["phase"],
 ): string | undefined {
-  if (confidence < INTENT_AT) return undefined;
-  const idle = phase === "idle";
-  if ((intent === "new-work" || intent === "fix") && (idle || intent === "new-work")) {
+  if (confidence < INTENT_AT || phase !== "idle") return undefined;
+  if (intent === "new-work" || intent === "fix") {
     return "This prompt asks for new work: call devsys_intake with the request before editing anything, so it is sized and the planning artifacts it needs are named.";
   }
-  if (intent === "review" && idle) {
+  if (intent === "review") {
     return "This prompt asks for a review: call devsys_review_start for a fresh-context review instead of reviewing in this conversation.";
   }
   return undefined;
 }
 
-/** Slash commands and empty prompts are not judged. */
-const judgeable = (prompt: string): boolean => {
-  const trimmed = prompt.trim();
-  return trimmed !== "" && !trimmed.startsWith("/");
-};
-
-/** Adapter: judge the prompt, and add the line to this run's guidelines. Jev trouble adds nothing. */
-export async function applyIntentGuideline(
-  event: BeforeAgentStartEvent,
+/**
+ * Adapter: judge the prompt and return the line for this run's context tail (not the system prompt,
+ * whose bytes every cached request shares). Idle sessions only, so a busy session pays no Jev call;
+ * an offline or failing Jev adds nothing instead of delaying the run.
+ */
+export async function intentLineFor(
+  prompt: string,
   state: DevsysState,
   jev: Jev,
-): Promise<void> {
-  if (!judgeable(event.prompt)) return;
-  const judged = await judgeIntent(jev, { prompt: event.prompt, phase: state.phase });
-  if (!judged.ok) return;
-  const line = intentGuideline(judged.value.intent, judged.value.confidence, state.phase);
-  if (line !== undefined) event.systemPromptOptions.promptGuidelines.push(line);
+): Promise<string | undefined> {
+  if (state.phase !== "idle" || prompt.trim() === "" || jev.availability() === "offline") {
+    return undefined;
+  }
+  const judged = await judgeIntent(jev, { prompt, phase: state.phase });
+  if (!judged.ok) return undefined;
+  return intentGuideline(judged.value.intent, judged.value.confidence, state.phase);
 }

package/src/context/turn-verifier.ts

@@ -59,8 +59,14 @@ export function asksUser(text: string): boolean {
   return QUESTION_END.test(lead) || (LIST_ITEM.test(last) && CHOICE_LEAD_IN.test(lead));
 }
 
+/** A recorded round, or a departure that waives review for the slice: either way the nudge has nothing to ask for. */
 const hasReviewRound = (state: DevsysState, slice: DevsysState["activeSlice"] & string): boolean =>
-  (reviewOf(state, slice)?.rounds.length ?? 0) > 0;
+  (reviewOf(state, slice)?.rounds.length ?? 0) > 0 ||
+  state.openDepartures.some(
+    (d) =>
+      d.gate === "review.unsatisfied" &&
+      (d.scope.kind === "session" || (d.scope.kind === "slice" && d.scope.slice === slice)),
+  );
 
 /** True when a scope.expansion departure already covers the slice: the remedy the note asks for exists. */
 const expansionRecorded = (state: DevsysState, slice: string): boolean =>