opencode-discipline 0.1.1 → 0.1.3

package/agents/explore.md

@@ -0,0 +1,43 @@
+---
+description: Fast codebase search. Finds files, patterns, and structure quickly. Cheap and parallel-friendly.
+model: openai/gpt-4.1-mini
+temperature: 0
+mode: subagent
+color: "#78909C"
+tools:
+  read: true
+  write: false
+  edit: false
+  bash: true
+  glob: true
+  grep: true
+  task: false
+permission:
+  bash:
+    "*": deny
+    "rtk *": allow
+    "find *": allow
+    "ls *": allow
+    "cat *": allow
+    "head *": allow
+    "tail *": allow
+    "wc *": allow
+    "git log *": allow
+    "git show *": allow
+---
+
+You are a fast codebase explorer. Your job is to find files, patterns, and structure as quickly as possible. You never implement or modify anything.
+
+## How you work
+
+1. Start with project structure — `ls`, file tree, config files
+2. Use Glob for file patterns, Grep for content search
+3. Read only what's relevant — don't dump entire files
+4. Return concise findings with exact file paths and line numbers
+
+## Rules
+
+- NEVER write or edit files
+- Be fast — breadth first, then drill into relevant areas
+- Return structured results the caller can act on immediately
+- If you can't find what's needed, say so

package/agents/plan.md

@@ -27,6 +27,12 @@ permission:
     "cargo check *": allow
     "cargo test --no-run *": allow
     "npm run type-check *": allow
+    "bun run type-check *": allow
+    "bun run type-check": allow
+    "bun test *": allow
+    "bun test": allow
+    "bun run build *": allow
+    "bun run build": allow
     "find *": allow
     "wc *": allow
     "mkdir *": allow
@@ -148,10 +154,13 @@ For high-stakes plans (production changes, data migrations, auth refactors):
 
 ### Presenting the plan
 
-After writing:
+After writing and completing Wave 4 review:
 1. Tell the user: "Plan written to `tasks/plans/{filename}.md`"
 2. Summarize in 3-5 sentences
-3. Say: "Review and edit the plan, then switch to Build to execute. Or ask me to revise."
+3. Present exactly three choices and ask the user to pick one:
+   - **Accept plan & start work** — Call `accept_plan(action="accept")` to create a new Build session with the plan registered. The Build agent will start implementing immediately.
+   - **Start work later** — Do nothing. The plan is saved and the user can start a Build session manually whenever they're ready.
+   - **I have modifications to make** — Call `accept_plan(action="revise")` and stay in Wave 4 to incorporate the user's feedback. After revisions, present these three choices again.
 
 ## Rules
 
@@ -162,3 +171,4 @@ After writing:
 - Prefer small phases (2-4 items). If a phase has 5+ items, split it.
 - Interleave tests with implementation — never "Phase N: write all tests."
 - A good plan lets the Build agent one-shot the implementation. That's the bar.
+- `advance_wave` and `accept_plan` are plugin tools you MUST call — they are not implementation actions. Calling them is part of your planning workflow, not a violation of read-only mode.

package/dist/index.js

@@ -12619,20 +12619,18 @@ var WAVE_NEXT_STEPS = {
   3: "writing the plan file",
   4: "plan review and refinement"
 };
+function hasStringProp(obj, key) {
+  return key in obj && typeof obj[key] === "string";
+}
 function extractSessionID(result) {
   if (!result || typeof result !== "object") {
     return;
   }
-  const value = result;
-  if (typeof value.id === "string") {
-    return value.id;
+  if (hasStringProp(result, "id")) {
+    return result.id;
   }
-  const data = value.data;
-  if (data && typeof data === "object") {
-    const dataRecord = data;
-    if (typeof dataRecord.id === "string") {
-      return dataRecord.id;
-    }
+  if ("data" in result && result.data && typeof result.data === "object" && hasStringProp(result.data, "id")) {
+    return result.data.id;
   }
   return;
 }
@@ -12735,11 +12733,8 @@ function extractTodos(response) {
   return [];
 }
 function hasPlanKickoffTodo(todos, planName) {
-  const planNameLower = planName.toLowerCase();
-  return todos.some((todo) => {
-    const content = todo.content.toLowerCase();
-    return content.includes(planNameLower) && content.includes("plan");
-  });
+  const expected = buildTodoSeedContent(planName).toLowerCase();
+  return todos.some((todo) => todo.content.toLowerCase().includes(expected));
 }
 async function readSessionTodos(client, directory, sessionID) {
   const sessionApi = client.session;
@@ -12752,197 +12747,212 @@ async function readSessionTodos(client, directory, sessionID) {
       path: { id: sessionID }
     });
     return extractTodos(response);
-  } catch {
+  } catch (error45) {
+    console.warn("[discipline] readSessionTodos failed:", error45);
     return;
   }
 }
-var DisciplinePlugin = async ({ worktree, directory, client }) => {
-  const manager = new WaveStateManager(worktree);
-  const todoNudges = new Map;
-  return {
-    "experimental.session.compacting": async (input, output) => {
-      const state = manager.getState(input.sessionID);
-      if (!state) {
-        return;
-      }
-      output.context.push(buildCompactionContext(state));
-    },
-    "experimental.chat.system.transform": async (input, output) => {
-      const sessionID = input.sessionID;
-      const state = sessionID ? manager.getState(sessionID) : undefined;
-      if (!state) {
-        output.system.push("## Discipline Plugin\nYou are operating under the opencode-discipline plugin. To start a structured plan, call `advance_wave` to begin Wave 1 (Interview).");
-        return;
+async function handleCompacting(ctx, input, output) {
+  const state = ctx.manager.getState(input.sessionID);
+  if (!state) {
+    return;
+  }
+  output.context.push(buildCompactionContext(state));
+}
+async function handleSystemTransform(ctx, input, output) {
+  const sessionID = input.sessionID;
+  const state = sessionID ? ctx.manager.getState(sessionID) : undefined;
+  if (!state) {
+    output.system.push("## Discipline Plugin\nYou are operating under the opencode-discipline plugin. To start a structured plan, call `advance_wave` to begin Wave 1 (Interview).");
+    return;
+  }
+  output.system.push(buildWaveStateSystemBlock(state.wave, state.planName));
+  const currentAgent = input.agent;
+  if (currentAgent === "plan" && state.wave < 3) {
+    output.system.push(buildPlanReadOnlyReminder());
+  }
+  if (sessionID && currentAgent === "plan" && !state.accepted) {
+    const nudgeState = ctx.todoNudges.get(sessionID) ?? {
+      prompted: false,
+      retried: false,
+      seeded: false
+    };
+    const todos = await readSessionTodos(ctx.client, ctx.directory, sessionID);
+    const hasSeededTodo = todos !== undefined && hasPlanKickoffTodo(todos, state.planName);
+    if (hasSeededTodo) {
+      nudgeState.seeded = true;
+    }
+    if (!nudgeState.seeded) {
+      if (!nudgeState.prompted) {
+        output.system.push(buildTodoSeedInstruction(state.planName, false));
+        nudgeState.prompted = true;
+      } else if (todos !== undefined && !hasSeededTodo && !nudgeState.retried) {
+        output.system.push(buildTodoSeedInstruction(state.planName, true));
+        nudgeState.retried = true;
       }
-      output.system.push(buildWaveStateSystemBlock(state.wave, state.planName));
-      const currentAgent = input.agent;
-      if (currentAgent === "plan" && state.wave < 3) {
-        output.system.push(buildPlanReadOnlyReminder());
+    }
+    ctx.todoNudges.set(sessionID, nudgeState);
+  }
+}
+async function handleToolExecuteBefore(ctx, input, output) {
+  const filePath = output.args?.filePath;
+  if (typeof filePath === "string") {
+    if (input.tool === "read" && isBlockedEnvRead(filePath)) {
+      throw new Error("Reading .env files is blocked by opencode-discipline.");
+    }
+    if (input.tool === "edit" || input.tool === "write") {
+      const state = ctx.manager.getState(input.sessionID);
+      if (state?.accepted) {
+        throw new Error('Plan session is read-only after accept_plan(action="accept"). Switch to Build for implementation.');
       }
-      if (sessionID && currentAgent === "plan" && !state.accepted) {
-        const nudgeState = todoNudges.get(sessionID) ?? {
-          prompted: false,
-          retried: false,
-          seeded: false
-        };
-        const todos = await readSessionTodos(client, directory, sessionID);
-        const hasSeededTodo = todos !== undefined && hasPlanKickoffTodo(todos, state.planName);
-        if (hasSeededTodo) {
-          nudgeState.seeded = true;
-        }
-        if (!nudgeState.seeded) {
-          if (!nudgeState.prompted) {
-            output.system.push(buildTodoSeedInstruction(state.planName, false));
-            nudgeState.prompted = true;
-          } else if (todos !== undefined && !hasSeededTodo && !nudgeState.retried) {
-            output.system.push(buildTodoSeedInstruction(state.planName, true));
-            nudgeState.retried = true;
-          }
-        }
-        todoNudges.set(sessionID, nudgeState);
+      if (state && state.wave < 3 && isPlanMarkdownFile(ctx.worktree, filePath)) {
+        throw new Error(`Cannot write plan files until Wave 3 (Plan Generation). Current wave: ${state.wave}. Call advance_wave to progress.`);
       }
+    }
+  }
+}
+function createAdvanceWaveTool(ctx) {
+  return tool({
+    description: "Advance the planning wave. Call this to move from one wave to the next. Wave 1: Interview, Wave 2: Gap Analysis, Wave 3: Plan Generation, Wave 4: Review. You must call this before starting each wave. The first call starts a new plan and generates the plan filename.",
+    args: {
+      sessionID: tool.schema.string().describe("The current session ID")
     },
-    "tool.execute.before": async (input, output) => {
-      const filePath = output.args?.filePath;
-      if (typeof filePath === "string") {
-        if (input.tool === "read" && isBlockedEnvRead(filePath)) {
-          throw new Error("Reading .env files is blocked by opencode-discipline.");
-        }
-        if (input.tool === "edit" || input.tool === "write") {
-          const state = manager.getState(input.sessionID);
-          if (state?.accepted) {
-            throw new Error('Plan session is read-only after accept_plan(action="accept"). Switch to Build for implementation.');
-          }
-          if (state && state.wave < 3 && isPlanMarkdownFile(worktree, filePath)) {
-            throw new Error(`Cannot write plan files until Wave 3 (Plan Generation). Current wave: ${state.wave}. Call advance_wave to progress.`);
-          }
+    async execute(args, context) {
+      if (context.agent !== "plan") {
+        return "Error: advance_wave is only available to the Plan agent.";
+      }
+      try {
+        const current = ctx.manager.getState(args.sessionID);
+        const state = current ? ctx.manager.advanceWave(args.sessionID) : ctx.manager.startPlan(args.sessionID);
+        if (!current) {
+          ctx.todoNudges.set(args.sessionID, {
+            prompted: false,
+            retried: false,
+            seeded: false
+          });
         }
+        const waveName = WAVE_NAMES[state.wave];
+        const nextStep = WAVE_NEXT_STEPS[state.wave];
+        return `Wave ${state.wave} (${waveName}) started for plan '${state.planName}'. You may now proceed with ${nextStep}.`;
+      } catch (error45) {
+        const message = error45 instanceof Error ? error45.message : "Unknown error";
+        return `Error: ${message}`;
       }
+    }
+  });
+}
+function createAcceptPlanTool(ctx) {
+  return tool({
+    description: "Accept or revise the generated plan. Use action='revise' to keep planning in Wave 4, or action='accept' to hand off to Build with only the plan path.",
+    args: {
+      sessionID: tool.schema.string().describe("The current plan session ID"),
+      action: tool.schema.enum(["accept", "revise"]),
+      planPath: tool.schema.string().optional().describe("Optional relative or absolute path to the plan file")
     },
-    tool: {
-      advance_wave: tool({
-        description: "Advance the planning wave. Call this to move from one wave to the next. Wave 1: Interview, Wave 2: Gap Analysis, Wave 3: Plan Generation, Wave 4: Review. You must call this before starting each wave. The first call starts a new plan and generates the plan filename.",
-        args: {
-          sessionID: tool.schema.string().describe("The current session ID")
-        },
-        async execute(args, context) {
-          if (context.agent !== "plan") {
-            return "Error: advance_wave is only available to the Plan agent.";
-          }
-          try {
-            const current = manager.getState(args.sessionID);
-            const state = current ? manager.advanceWave(args.sessionID) : manager.startPlan(args.sessionID);
-            if (!current) {
-              todoNudges.set(args.sessionID, {
-                prompted: false,
-                retried: false,
-                seeded: false
-              });
-            }
-            const waveName = WAVE_NAMES[state.wave];
-            const nextStep = WAVE_NEXT_STEPS[state.wave];
-            return `Wave ${state.wave} (${waveName}) started for plan '${state.planName}'. You may now proceed with ${nextStep}.`;
-          } catch (error45) {
-            const message = error45 instanceof Error ? error45.message : "Unknown error";
-            return `Error: ${message}`;
-          }
-        }
-      }),
-      accept_plan: tool({
-        description: "Accept or revise the generated plan. Use action='revise' to keep planning in Wave 4, or action='accept' to hand off to Build with only the plan path.",
-        args: {
-          sessionID: tool.schema.string().describe("The current plan session ID"),
-          action: tool.schema.enum(["accept", "revise"]),
-          planPath: tool.schema.string().optional().describe("Optional relative or absolute path to the plan file")
-        },
-        async execute(args, context) {
-          if (context.agent !== "plan") {
-            return "Error: accept_plan is only available to the Plan agent.";
-          }
-          const state = manager.getState(args.sessionID);
-          if (!state) {
-            return `Error: No active plan found for session '${args.sessionID}'.`;
-          }
-          const defaultPlanPath = `tasks/plans/${state.planName}.md`;
-          const resolvedPlanPath = args.planPath ?? defaultPlanPath;
-          const absolutePlanPath = resolve(worktree, resolvedPlanPath);
-          const relativePlanPath = toWorktreeRelativePath(worktree, absolutePlanPath);
-          if (!isPlanMarkdownFile(worktree, absolutePlanPath)) {
-            return "Error: planPath must point to tasks/plans/{planName}.md within the current worktree.";
-          }
-          if (args.action === "revise") {
-            const nextStep = state.wave < 4 ? "Next step: call advance_wave until Wave 4, then continue review/revision." : "Next step: continue in Wave 4 review/revision and update the plan as needed.";
-            return [
-              "Plan revision requested.",
-              `Current wave: ${state.wave} (${getWaveLabel(state.wave)}).`,
-              `Plan file: ${relativePlanPath}`,
-              nextStep
-            ].join(" ");
-          }
-          if (state.wave !== 4) {
-            return `Error: accept_plan(action="accept") is only available in Wave 4 (Review). Current wave: ${state.wave}.`;
-          }
-          try {
-            accessSync(absolutePlanPath, constants.R_OK);
-          } catch {
-            return `Error: Plan file '${relativePlanPath}' is missing or unreadable.`;
-          }
-          let buildSessionID = "manual-build-session";
-          let fallback = false;
-          const sessionApi = client.session;
-          const canCreate = sessionApi && typeof sessionApi.create === "function";
-          const canPrompt = sessionApi && typeof sessionApi.prompt === "function";
-          if (canCreate && canPrompt) {
-            try {
-              const createResult = await sessionApi.create({
-                query: { directory },
-                body: { title: `Build handoff: ${state.planName}` }
-              });
-              const createdSessionID = extractSessionID(createResult);
-              if (!createdSessionID) {
-                fallback = true;
-              } else {
-                buildSessionID = createdSessionID;
-                await sessionApi.prompt({
-                  query: { directory },
-                  path: { id: createdSessionID },
-                  body: {
-                    agent: "build",
-                    system: "Use only this file as source of truth; do not rely on Plan context.",
-                    parts: [
-                      {
-                        type: "text",
-                        text: `Read ${relativePlanPath} and implement it phase-by-phase. Use only this plan file as handoff context.`
-                      }
-                    ]
+    async execute(args, context) {
+      if (context.agent !== "plan") {
+        return "Error: accept_plan is only available to the Plan agent.";
+      }
+      const state = ctx.manager.getState(args.sessionID);
+      if (!state) {
+        return `Error: No active plan found for session '${args.sessionID}'.`;
+      }
+      const defaultPlanPath = `tasks/plans/${state.planName}.md`;
+      const resolvedPlanPath = args.planPath ?? defaultPlanPath;
+      const absolutePlanPath = resolve(ctx.worktree, resolvedPlanPath);
+      const relativePlanPath = toWorktreeRelativePath(ctx.worktree, absolutePlanPath);
+      if (!isPlanMarkdownFile(ctx.worktree, absolutePlanPath)) {
+        return "Error: planPath must point to tasks/plans/{planName}.md within the current worktree.";
+      }
+      if (args.action === "revise") {
+        const nextStep = state.wave < 4 ? "Next step: call advance_wave until Wave 4, then continue review/revision." : "Next step: continue in Wave 4 review/revision and update the plan as needed.";
+        return [
+          "Plan revision requested.",
+          `Current wave: ${state.wave} (${getWaveLabel(state.wave)}).`,
+          `Plan file: ${relativePlanPath}`,
+          nextStep
+        ].join(" ");
+      }
+      if (state.wave !== 4) {
+        return `Error: accept_plan(action="accept") is only available in Wave 4 (Review). Current wave: ${state.wave}.`;
+      }
+      try {
+        accessSync(absolutePlanPath, constants.R_OK);
+      } catch {
+        return `Error: Plan file '${relativePlanPath}' is missing or unreadable.`;
+      }
+      let buildSessionID = "manual-build-session";
+      let fallback = false;
+      const sessionApi = ctx.client.session;
+      const canCreate = sessionApi && typeof sessionApi.create === "function";
+      const canPrompt = sessionApi && typeof sessionApi.prompt === "function";
+      if (canCreate && canPrompt) {
+        try {
+          const createResult = await sessionApi.create({
+            query: { directory: ctx.directory },
+            body: { title: `Build handoff: ${state.planName}` }
+          });
+          const createdSessionID = extractSessionID(createResult);
+          if (!createdSessionID) {
+            fallback = true;
+          } else {
+            buildSessionID = createdSessionID;
+            await sessionApi.prompt({
+              query: { directory: ctx.directory },
+              path: { id: createdSessionID },
+              body: {
+                agent: "build",
+                system: "Use only this file as source of truth; do not rely on Plan context.",
+                parts: [
+                  {
+                    type: "text",
+                    text: `Read ${relativePlanPath} and implement it phase-by-phase. Use only this plan file as handoff context.`
                   }
-                });
+                ]
               }
-            } catch {
-              fallback = true;
-            }
-          } else {
-            fallback = true;
-          }
-          const acceptedState = manager.markAccepted(args.sessionID, buildSessionID);
-          if (fallback) {
-            return [
-              "Plan accepted.",
-              `Plan file: ${relativePlanPath}`,
-              "Direct session handoff is unavailable in this environment.",
-              "Fallback: switch to Build agent and read the plan file first.",
-              `State saved with accepted timestamp ${acceptedState.acceptedAt}.`
-            ].join(" ");
+            });
           }
-          return [
-            "Plan accepted and handed off to Build.",
-            `Plan file: ${relativePlanPath}`,
-            `Build session: ${buildSessionID}`,
-            "First build action seeded: read the plan file with clean handoff context.",
-            `State saved with accepted timestamp ${acceptedState.acceptedAt}.`
-          ].join(" ");
-        }
-      })
+        } catch {
+          fallback = true;
+        }
+      } else {
+        fallback = true;
+      }
+      const acceptedState = ctx.manager.markAccepted(args.sessionID, buildSessionID);
+      if (fallback) {
+        return [
+          "Plan accepted.",
+          `Plan file: ${relativePlanPath}`,
+          "Direct session handoff is unavailable in this environment.",
+          "Fallback: switch to Build agent and read the plan file first.",
+          `State saved with accepted timestamp ${acceptedState.acceptedAt}.`
+        ].join(" ");
+      }
+      return [
+        "Plan accepted and handed off to Build.",
+        `Plan file: ${relativePlanPath}`,
+        `Build session: ${buildSessionID}`,
+        "First build action seeded: read the plan file with clean handoff context.",
+        `State saved with accepted timestamp ${acceptedState.acceptedAt}.`
+      ].join(" ");
+    }
+  });
+}
+var DisciplinePlugin = async ({ worktree, directory, client }) => {
+  const ctx = {
+    manager: new WaveStateManager(worktree),
+    todoNudges: new Map,
+    worktree,
+    directory,
+    client
+  };
+  return {
+    "experimental.session.compacting": (input, output) => handleCompacting(ctx, input, output),
+    "experimental.chat.system.transform": (input, output) => handleSystemTransform(ctx, input, output),
+    "tool.execute.before": (input, output) => handleToolExecuteBefore(ctx, input, output),
+    tool: {
+      advance_wave: createAdvanceWaveTool(ctx),
+      accept_plan: createAcceptPlanTool(ctx)
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discipline",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",