opencode-discipline 0.1.0 → 0.1.2

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;
 }
@@ -12703,163 +12701,258 @@ function buildCompactionContext(state) {
   ].join(`
 `);
 }
-var DisciplinePlugin = async ({ worktree, directory, client }) => {
-  const manager = new WaveStateManager(worktree);
-  return {
-    "experimental.session.compacting": async (input, output) => {
-      const state = manager.getState(input.sessionID);
-      if (!state) {
-        return;
+function buildTodoSeedContent(planName) {
+  return `Plan kickoff: ${planName}`;
+}
+function buildTodoSeedInstruction(planName, retry) {
+  const content = buildTodoSeedContent(planName);
+  const title = retry ? "## Discipline Plugin \u2014 Todo Seed Retry" : "## Discipline Plugin \u2014 Todo Seed";
+  const intro = retry ? "The plan kickoff todo is still missing in the right panel." : "Before continuing, create the kickoff todo so progress is visible in the right panel.";
+  return [
+    title,
+    intro,
+    "Call `todowrite` now with this item:",
+    `- content: \`${content}\``,
+    "- status: `in_progress`",
+    "- priority: `high`"
+  ].join(`
+`);
+}
+function extractTodos(response) {
+  if (Array.isArray(response)) {
+    return response.filter((item) => {
+      return typeof item === "object" && item !== null && typeof item.content === "string" && typeof item.status === "string" && typeof item.priority === "string";
+    });
+  }
+  if (response && typeof response === "object") {
+    const data = response.data;
+    if (Array.isArray(data)) {
+      return extractTodos(data);
+    }
+  }
+  return [];
+}
+function hasPlanKickoffTodo(todos, planName) {
+  const expected = buildTodoSeedContent(planName).toLowerCase();
+  return todos.some((todo) => todo.content.toLowerCase().includes(expected));
+}
+async function readSessionTodos(client, directory, sessionID) {
+  const sessionApi = client.session;
+  if (!sessionApi || typeof sessionApi.todo !== "function") {
+    return;
+  }
+  try {
+    const response = await sessionApi.todo({
+      query: { directory },
+      path: { id: sessionID }
+    });
+    return extractTodos(response);
+  } catch (error45) {
+    console.warn("[discipline] readSessionTodos failed:", error45);
+    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.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;
+    }
+    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.');
       }
-      output.system.push(buildWaveStateSystemBlock(state.wave, state.planName));
-      const currentAgent = input.agent;
-      if (currentAgent === "plan" && state.wave < 3) {
-        output.system.push(buildPlanReadOnlyReminder());
+      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);
-            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.0",
+  "version": "0.1.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",