@jwilger/pi-development-system 0.68.0 → 0.70.0

package/extensions/development-system.ts

@@ -19,6 +19,7 @@ import { registerRedFirstGuard } from "../src/gates/red-first-guard.ts";
 import { createRequestApprovalTool } from "../src/gates/request-approval-tool.ts";
 import { registerTestGuard } from "../src/gates/test-guard.ts";
 import { createJevHolder } from "../src/jev/holder.ts";
+import { createBeginWorkTool } from "../src/planning/begin-tool.ts";
 import { createIntakeTool } from "../src/planning/intake-tool.ts";
 import { createTaskCheckTool } from "../src/planning/task-check-tool.ts";
 import { createReviewRecordTool, createReviewStartTool } from "../src/review/review-tools.ts";
@@ -141,6 +142,7 @@ export function createDevelopmentSystem(pi: ExtensionAPI) {
   pi.registerTool(createRequestApprovalTool({ pi, approvals }));
   pi.registerTool(createModelsTool());
   pi.registerTool(createRouteTaskTool({ jev: (ctx) => jevHolder.forContext(ctx) }));
+  pi.registerTool(createBeginWorkTool({ state }));
   pi.registerTool(createIntakeTool({ pi, state, jev: (ctx) => jevHolder.forContext(ctx) }));
   pi.registerTool(createTaskCheckTool({ jev: (ctx) => jevHolder.forContext(ctx) }));
   pi.registerTool(createWorkItemTool({ exec }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwilger/pi-development-system",
-  "version": "0.68.0",
+  "version": "0.70.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: 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 plan is built). 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.

package/prompts/devsys-start.md

@@ -6,5 +6,6 @@ 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 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.
+3. Produce the planning artifacts first (brief, 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; once the user approves them, call `devsys_begin_work` so the review and red-first gates switch on.
+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.

package/skills/work-intake-and-slicing/SKILL.md

@@ -54,4 +54,4 @@ Use `devsys_work_item` for the backlog. It reads `[tracker] kind` from `.develop
 
 ## Handing off
 
-`/devsys-plan <slug>` writes `docs/plan/<slug>.md` in this structure and, when a goal tool is available, starts a goal to complete it. Review the plan with the user before any implementation.
+`/devsys-plan <slug>` writes `docs/plan/<slug>.md` in this structure and checks every task record. Then it stops for the user to review the plan. Only after they approve does it call `devsys_begin_work` (planning → implementing, which switches the review and red-first gates on) and start a goal to complete the plan, when a goal tool is available: a goal can begin implementing on its own, so it must not exist before the review.

package/src/planning/begin-tool.ts

@@ -0,0 +1,47 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import type { SessionState } from "../state/session-state.ts";
+
+const Parameters = Type.Object({});
+
+const reply = (text: string, isError = false) => ({
+  content: [{ type: "text" as const, text }],
+  details: undefined,
+  isError,
+});
+
+/**
+ * `devsys_begin_work`: the planning → implementing transition. Intake leaves capability and product work in
+ * `planning`; the review and red-first gates only run while implementing, so without this step the largest work
+ * would get the fewest gates. Call it once the user has approved the plan.
+ */
+export function createBeginWorkTool(deps: {
+  state: SessionState;
+}): ToolDefinition<typeof Parameters> {
+  return {
+    name: "devsys_begin_work",
+    label: "Begin implementing",
+    description:
+      "Move from planning to implementing once the user has approved the plan. This switches on the review and red-first gates for the active slice.",
+    promptSnippet: "Start implementing after the plan is approved",
+    parameters: Parameters,
+    exposure: "direct",
+    execute(_id, _params: Static<typeof Parameters>) {
+      const { phase, activeSlice } = deps.state.get();
+      if (phase !== "planning" || activeSlice === undefined) {
+        return Promise.resolve(
+          reply(
+            `Nothing to begin: phase is ${phase}${activeSlice === undefined ? " with no active slice" : ""}. Use devsys_intake to size new work first.`,
+            true,
+          ),
+        );
+      }
+      deps.state.update((s) => ({ ...s, phase: "implementing" }));
+      return Promise.resolve(
+        reply(
+          `Phase: implementing. Active slice: ${activeSlice}. Review and red-first gates are now on.`,
+        ),
+      );
+    },
+  };
+}

package/src/planning/task-record.ts

@@ -34,7 +34,7 @@ const STEPS_MIN = 3;
 const STEPS_MAX = 7;
 /** Words that stand in for a command or an observable result. */
 const PLACEHOLDER =
-  /^(?:(?:tbd|tbc)\b.*|todo\s*(?::.*)?|n\/?a|none|-|…|\.\.\.|works?|it works|passes|ok)\.?$/i;
+  /^(?:(?:tbd|tbc)\b.*|todo\s*(?::.*)?|n\/?a|none|[-—–]|…|\.\.\.|<[^<>]*>|works?|it works|passes|ok)\.?$/i;
 
 const isSection = (name: string): name is Section => SECTIONS.some((s) => s === name);
 
@@ -176,7 +176,7 @@ function problemsOf(markdown: string, split: Sections): string[] {
   }
   const missing = SECTIONS.filter((s) => got(sections, s) === "");
   if (missing.length > 0) problems.push(`missing section: ${missing.join(", ")}`);
-  if (/\bTBD\b/.test(markdown)) problems.push("contains TBD; decide it or split the task");
+  if (/\bTBD\b/i.test(markdown)) problems.push("contains TBD; decide it or split the task");
   const steps = stepsOf(get(sections, "Steps"));
   if (!missing.includes("Steps") && (steps.length < STEPS_MIN || steps.length > STEPS_MAX)) {
     problems.push(`Steps must be ${STEPS_MIN}-${STEPS_MAX} steps, found ${steps.length}`);