@umgbhalla/pi-gigaplan 0.1.0 → 0.1.2

package/extensions/index.ts

@@ -43,7 +43,7 @@ import {
   activePlanDirs,
   resolvePlanDir,
   loadPlan,
-  saveState,
+  savePlanState,
   latestPlanRecord,
   latestPlanPath,
   latestPlanMetaPath,
@@ -173,7 +173,7 @@ function initPlan(
     last_evaluation: {},
   };
 
-  saveState(planDir, state);
+  savePlanState(planDir, state);
   saveFlagRegistry(planDir, { flags: [] });
 
   return { planDir, state };
@@ -202,7 +202,7 @@ function processStepOutput(
         duration_ms: durationMs,
         result: "success",
       });
-      saveState(planDir, state);
+      savePlanState(planDir, state);
       return {
         success: true,
         step: "clarify",
@@ -264,7 +264,7 @@ function processStepOutput(
         result: "success",
         output_file: planFile,
       });
-      saveState(planDir, state);
+      savePlanState(planDir, state);
 
       return {
         success: true,
@@ -324,7 +324,7 @@ function processStepOutput(
         output_file: critiqueFile,
         flags_count: newFlags.length,
       });
-      saveState(planDir, state);
+      savePlanState(planDir, state);
 
       return {
         success: true,
@@ -345,7 +345,7 @@ function processStepOutput(
         result: "success",
         output_file: "execution.json",
       });
-      saveState(planDir, state);
+      savePlanState(planDir, state);
 
       return {
         success: true,
@@ -366,7 +366,7 @@ function processStepOutput(
         result: "success",
         output_file: "review.json",
       });
-      saveState(planDir, state);
+      savePlanState(planDir, state);
 
       const criteria = (payload.criteria as Array<{ name: string; pass: boolean }>) ?? [];
       const passed = criteria.filter((c) => c.pass).length;
@@ -405,7 +405,7 @@ function runEvaluate(planDir: string, state: PlanState): StepResult {
     (evaluation.signals as Record<string, unknown>).weighted_score as number,
   ];
 
-  state.last_evaluation = evaluation;
+  state.last_evaluation = evaluation as unknown as Record<string, unknown>;
   state.current_state = STATE_EVALUATED;
   state.history.push({
     step: "evaluate",
@@ -414,13 +414,13 @@ function runEvaluate(planDir: string, state: PlanState): StepResult {
     recommendation: evaluation.recommendation,
     output_file: evalFile,
   });
-  saveState(planDir, state);
+  savePlanState(planDir, state);
 
   return {
     success: true,
     step: "evaluate",
     summary: `Evaluation: ${evaluation.recommendation} (${evaluation.confidence} confidence). ${evaluation.rationale}`,
-    nextSteps: evaluation.valid_next_steps,
+    nextSteps: evaluation.valid_next_steps ?? [],
     artifacts: [evalFile],
   };
 }
@@ -470,7 +470,7 @@ function runGate(planDir: string, state: PlanState): StepResult {
     timestamp: nowUtc(),
     result: passed ? "success" : "failed",
   });
-  saveState(planDir, state);
+  savePlanState(planDir, state);
 
   return {
     success: passed,
@@ -492,7 +492,8 @@ export default function gigaplanExtension(pi: ExtensionAPI) {
   // Widget state
   let activePlan: { name: string; state: string; step: string } | null = null;
 
-  function updateWidget(ctx: any) {
+  function updateWidget(ctx?: any) {
+    if (!ctx?.ui) return;
     if (!activePlan) {
       ctx.ui.setStatus("gigaplan", "");
       return;
@@ -514,11 +515,14 @@ export default function gigaplanExtension(pi: ExtensionAPI) {
       }
 
       // Ask for configuration
-      const robustness = await ctx.ui.select("Robustness level", [
-        { label: "Light — pragmatic, fast", value: "light" },
-        { label: "Standard — balanced (default)", value: "standard" },
-        { label: "Thorough — exhaustive review", value: "thorough" },
-      ]);
+      const ROBUSTNESS_OPTIONS = ["Light — pragmatic, fast", "Standard — balanced (default)", "Thorough — exhaustive review"];
+      const ROBUSTNESS_MAP: Record<string, string> = {
+        [ROBUSTNESS_OPTIONS[0]]: "light",
+        [ROBUSTNESS_OPTIONS[1]]: "standard",
+        [ROBUSTNESS_OPTIONS[2]]: "thorough",
+      };
+      const robustnessChoice = await ctx.ui.select("Robustness level", ROBUSTNESS_OPTIONS);
+      const robustness = ROBUSTNESS_MAP[robustnessChoice ?? ""] ?? "standard";
 
       const autoApprove = await ctx.ui.confirm(
         "Auto-approve?",
@@ -528,14 +532,14 @@ export default function gigaplanExtension(pi: ExtensionAPI) {
       // Initialize
       const root = ctx.cwd;
       const { planDir, state } = initPlan(root, idea, {
-        robustness: robustness ?? "standard",
+        robustness,
         autoApprove,
       });
 
       activePlan = { name: state.name, state: state.current_state, step: "clarify" };
       updateWidget(ctx);
 
-      ctx.ui.notify(`Plan "${state.name}" initialized. Starting orchestration...`, "success");
+      ctx.ui.notify(`Plan "${state.name}" initialized. Starting orchestration...`, "info");
 
       // Send orchestration prompt to the LLM
       const orchestrationPrompt = `You are now in **gigaplan mode**. A structured plan has been initialized.
@@ -613,7 +617,7 @@ Start now with the **clarify** step.`;
       } catch (e) {
         return {
           content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
-          details: { error: true },
+          details: { error: true } as any,
         };
       }
     },
@@ -633,7 +637,7 @@ Start now with the **clarify** step.`;
       durationMs: Type.Optional(Type.Number({ description: "How long the step took in ms" })),
     }),
 
-    async execute(_id, params) {
+    async execute(_id, params, _signal, _onUpdate, ctx) {
       try {
         const state = readJson(path.join(params.planDir, "state.json")) as PlanState;
         let result: StepResult;
@@ -659,7 +663,7 @@ Start now with the **clarify** step.`;
         if (activePlan) {
           activePlan.state = result.step;
           activePlan.step = result.nextSteps[0] ?? "done";
-          updateWidget(null as any); // TODO: need ctx
+          updateWidget(ctx);
         }
 
         const nextAction = result.nextSteps.length > 0
@@ -682,7 +686,7 @@ Start now with the **clarify** step.`;
       } catch (e) {
         return {
           content: [{ type: "text", text: `Error advancing: ${e instanceof Error ? e.message : String(e)}` }],
-          details: { error: true },
+          details: { error: true } as any,
         };
       }
     },
@@ -789,14 +793,14 @@ Start now with the **clarify** step.`;
               timestamp: nowUtc(),
               message: `add-note: ${params.note}`,
             });
-            saveState(params.planDir, state);
+            savePlanState(params.planDir, state);
             return { content: [{ type: "text", text: `Note added. Continue with the current step.` }], details: {} };
           }
 
           case "abort": {
             state.current_state = STATE_ABORTED;
             state.history.push({ step: "override", timestamp: nowUtc(), message: "aborted" });
-            saveState(params.planDir, state);
+            savePlanState(params.planDir, state);
             return { content: [{ type: "text", text: `Plan "${state.name}" aborted.` }], details: {} };
           }
 
@@ -808,10 +812,10 @@ Start now with the **clarify** step.`;
               timestamp: nowUtc(),
               message: "force-proceed (bypassed gate)",
             });
-            saveState(params.planDir, state);
+            savePlanState(params.planDir, state);
             return {
               content: [{ type: "text", text: "Force-proceeded to gate. Next step: execute." }],
-              details: { nextSteps: ["execute"] },
+              details: { nextSteps: ["execute"] } as any,
             };
           }
 
@@ -823,10 +827,10 @@ Start now with the **clarify** step.`;
               timestamp: nowUtc(),
               message: "skip (user override to SKIP)",
             });
-            saveState(params.planDir, state);
+            savePlanState(params.planDir, state);
             return {
               content: [{ type: "text", text: "Skipped to gate. Next step: gate." }],
-              details: { nextSteps: ["gate"] },
+              details: { nextSteps: ["gate"] } as any,
             };
           }
 
@@ -839,7 +843,7 @@ Start now with the **clarify** step.`;
       } catch (e) {
         return {
           content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
-          details: { error: true },
+          details: { error: true } as any,
         };
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umgbhalla/pi-gigaplan",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Structured AI planning with cross-model critique — gigaplan as a pi extension",
   "keywords": [
     "pi-package",

package/skills/gigaplan/SKILL.md

@@ -40,7 +40,7 @@ For **evaluate** and **gate** steps: skip the subagent, just call `gigaplan_adva
 ```
 clarify → plan → critique → evaluate
                                 ↓
-              CONTINUE → integrate → plan (loop)
+              CONTINUE → integrate → critique (loop)
               SKIP → gate → execute → review → done
               ESCALATE → ask user → override
               ABORT → done

package/src/evaluation.ts

@@ -270,7 +270,7 @@ export function buildEvaluation(planDir: string, state: PlanState): EvaluationRe
   const robustness = configuredRobustness(state);
   const skipThreshold = ROBUSTNESS_SKIP_THRESHOLDS[robustness] ?? 2.0;
   const stagnationFactor = ROBUSTNESS_STAGNATION_FACTORS[robustness] ?? 0.9;
-  const openScopeCreep = scopeCreepFlags(flagRegistry, FLAG_BLOCKING_STATUSES);
+  const openScopeCreep = scopeCreepFlags(flagRegistry, { statuses: FLAG_BLOCKING_STATUSES });
   const significantCount = flagRegistry.flags.filter(
     (f) => f.severity === "significant" && f.status !== "verified",
   ).length;

package/src/prompts.ts

@@ -4,7 +4,8 @@ import * as fs from "fs";
 import * as path from "path";
 import {
   PlanState,
-  CliError,
+  FlagRecord,
+  GigaplanError,
   latestPlanPath,
   readJson,
   latestPlanMetaPath,
@@ -23,7 +24,7 @@ function clarifyPrompt(state: PlanState, planDir: string): string {
   const notes = state.meta?.notes ?? [];
   const notesBlock =
     notes.length > 0
-      ? notes.map((n: { note: string }) => `- ${n.note}`).join("\n")
+      ? notes.map((n: Record<string, unknown>) => `- ${n.note}`).join("\n")
       : "- None";
   return `
 You are a planning assistant. The user has proposed the following idea:
@@ -52,7 +53,7 @@ function planPrompt(state: PlanState, planDir: string): string {
   const notes = state.meta?.notes ?? [];
   const notesBlock =
     notes.length > 0
-      ? notes.map((n: { note: string }) => `- ${n.note}`).join("\n")
+      ? notes.map((n: Record<string, unknown>) => `- ${n.note}`).join("\n")
       : "- None";
   const clarification = state.clarification ?? {};
   const refined = clarification.refined_idea ?? "";
@@ -103,7 +104,7 @@ function integratePrompt(state: PlanState, planDir: string): string {
   );
   const evaluation = readJson(evaluatePath);
   const unresolved = unresolvedSignificantFlags(flagRegistry);
-  const openFlags = unresolved.map((flag: Record<string, unknown>) => ({
+  const openFlags = unresolved.map((flag) => ({
     id: flag.id,
     severity: flag.severity,
     status: flag.status,
@@ -151,10 +152,10 @@ function critiquePrompt(state: PlanState, planDir: string): string {
   const flagRegistry = loadFlagRegistry(planDir);
   const robustness = configuredRobustness(state);
   const unresolved = flagRegistry.flags
-    .filter((flag: Record<string, unknown>) =>
+    .filter((flag) =>
       ["addressed", "open", "disputed"].includes(flag.status as string)
     )
-    .map((flag: Record<string, unknown>) => ({
+    .map((flag) => ({
       id: flag.id,
       concern: flag.concern,
       status: flag.status,
@@ -255,7 +256,7 @@ function reviewClaudePrompt(state: PlanState, planDir: string): string {
   const latestMeta = readJson(latestPlanMetaPath(planDir, state));
   const execution = readJson(path.join(planDir, "execution.json"));
   const gate = readJson(path.join(planDir, "gate.json"));
-  const diffSummary = collectGitDiffSummary(projectDir);
+  const diffSummary = collectGitDiffSummary(projectDir ?? process.cwd());
   return `
 Review the execution critically against user intent and observable success criteria.
 
@@ -294,7 +295,7 @@ function reviewCodexPrompt(state: PlanState, planDir: string): string {
   );
   const latestMeta = readJson(latestPlanMetaPath(planDir, state));
   const execution = readJson(path.join(planDir, "execution.json"));
-  const diffSummary = collectGitDiffSummary(projectDir);
+  const diffSummary = collectGitDiffSummary(projectDir ?? process.cwd());
   return `
 Review the implementation against the success criteria.
 
@@ -358,7 +359,7 @@ export function createPrompt(
     agent === "codex" ? CODEX_PROMPT_BUILDERS : CLAUDE_PROMPT_BUILDERS;
   const builder = builders[step];
   if (!builder) {
-    throw new CliError(
+    throw new GigaplanError(
       "unsupported_step",
       `Unsupported ${agent} step '${step}'`
     );

package/src/workers.ts

@@ -60,6 +60,82 @@ function getRequiredKeys(step: string): string[] {
   return (schema?.required as string[] | undefined) ?? [];
 }
 
+function getStepSchema(step: string): Record<string, unknown> | undefined {
+  const filename = STEP_SCHEMA_FILENAMES[step];
+  if (!filename) return undefined;
+  return SCHEMAS[filename] as Record<string, unknown> | undefined;
+}
+
+function describeType(value: unknown): string {
+  if (Array.isArray(value)) return "array";
+  if (value === null) return "null";
+  return typeof value;
+}
+
+function validateValueAgainstSchema(
+  value: unknown,
+  schema: Record<string, unknown> | undefined,
+  keyPath: string,
+): void {
+  if (!schema) return;
+
+  const expectedType = schema.type as string | undefined;
+  if (expectedType === "string" && typeof value !== "string") {
+    throw new GigaplanError(
+      "parse_error",
+      `${keyPath} must be a string, got ${describeType(value)}`,
+    );
+  }
+  if (expectedType === "boolean" && typeof value !== "boolean") {
+    throw new GigaplanError(
+      "parse_error",
+      `${keyPath} must be a boolean, got ${describeType(value)}`,
+    );
+  }
+  if (expectedType === "array") {
+    if (!Array.isArray(value)) {
+      throw new GigaplanError(
+        "parse_error",
+        `${keyPath} must be an array, got ${describeType(value)}`,
+      );
+    }
+    const itemSchema = schema.items as Record<string, unknown> | undefined;
+    value.forEach((item, index) => {
+      validateValueAgainstSchema(item, itemSchema, `${keyPath}[${index}]`);
+    });
+    return;
+  }
+  if (expectedType === "object") {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new GigaplanError(
+        "parse_error",
+        `${keyPath} must be an object, got ${describeType(value)}`,
+      );
+    }
+
+    const obj = value as Record<string, unknown>;
+    const required = (schema.required as string[] | undefined) ?? [];
+    const missing = required.filter((k) => !(k in obj));
+    if (missing.length > 0) {
+      throw new GigaplanError(
+        "parse_error",
+        `${keyPath} missing required keys: ${missing.join(", ")}`,
+      );
+    }
+
+    const properties = (schema.properties as Record<string, unknown> | undefined) ?? {};
+    for (const [prop, propSchema] of Object.entries(properties)) {
+      if (prop in obj) {
+        validateValueAgainstSchema(
+          obj[prop],
+          propSchema as Record<string, unknown>,
+          keyPath === "payload" ? prop : `${keyPath}.${prop}`,
+        );
+      }
+    }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Validation
 // ---------------------------------------------------------------------------
@@ -73,6 +149,8 @@ export function validatePayload(step: string, payload: Record<string, unknown>):
       `${step} output missing required keys: ${missing.join(", ")}`,
     );
   }
+
+  validateValueAgainstSchema(payload, getStepSchema(step), "payload");
 }
 
 // ---------------------------------------------------------------------------
@@ -104,6 +182,44 @@ export function resolveAgent(step: string, state: PlanState): AgentRouting {
 // Build subagent task
 // ---------------------------------------------------------------------------
 
+function stepOutputChecklist(step: string): string {
+  switch (step) {
+    case "clarify":
+      return [
+        '- Top-level keys: `questions`, `refined_idea`, `intent_summary`.',
+        '- `questions` must be an array of objects with `question` and `context`.',
+      ].join("\n");
+    case "plan":
+      return [
+        '- Top-level keys: `plan`, `questions`, `success_criteria`, `assumptions`.',
+        '- `plan` must be a markdown string, not an array or object.',
+      ].join("\n");
+    case "integrate":
+      return [
+        '- Top-level keys: `plan`, `changes_summary`, `flags_addressed`, `assumptions`, `success_criteria`, `questions`.',
+        '- `plan` must be a markdown string.',
+        '- `flags_addressed` must contain exact flag IDs from critique.',
+      ].join("\n");
+    case "critique":
+      return [
+        '- Top-level keys: `flags`, `verified_flag_ids`, `disputed_flag_ids`.',
+        '- Use `flags`, not `significant_issues` or any alternate field name.',
+        '- Each `flags[]` item must include exactly: `id`, `concern`, `category`, `severity_hint`, `evidence`.',
+      ].join("\n");
+    case "execute":
+      return [
+        '- Top-level keys: `output`, `files_changed`, `commands_run`, `deviations`.',
+      ].join("\n");
+    case "review":
+      return [
+        '- Top-level keys: `criteria`, `issues`, `summary`.',
+        '- Each `criteria[]` item must include `name`, `pass`, `evidence`.',
+      ].join("\n");
+    default:
+      return "- Follow the schema exactly.";
+  }
+}
+
 /**
  * Build the full task prompt for a subagent.
  * Includes the step prompt + instructions to write structured output.
@@ -131,6 +247,9 @@ ${prompt}
 You MUST write your response as a valid JSON object to this file:
 \`${outputPath}\`
 
+Checklist:
+${stepOutputChecklist(step)}
+
 The JSON must conform to this schema:
 \`\`\`json
 ${JSON.stringify(strict, null, 2)}