aiwcli 0.15.5 → 0.17.0

package/dist/templates/cc-native/_cc-native/scripts/council_debate.ts

@@ -0,0 +1,242 @@
+#!/usr/bin/env bun
+/**
+ * Council debate runner for architectural decisions.
+ * Uses multi-agent infrastructure to simulate structured debate.
+ */
+
+import { runAgentReview } from "../lib-ts/reviewers/agent.js";
+import type { AgentConfig } from "../lib-ts/reviewers/types.js";
+import { logInfo, logError } from "../../_core/lib-ts/runtime/logger.js";
+
+// Debate schema - each agent responds with their perspective
+const DEBATE_SCHEMA = {
+  type: "object",
+  properties: {
+    agent_name: { type: "string", description: "Name of this agent/perspective" },
+    position: {
+      type: "string",
+      enum: ["approach_a", "approach_b", "hybrid", "neither"],
+      description: "Which approach this agent supports"
+    },
+    reasoning: {
+      type: "array",
+      items: { type: "string" },
+      description: "Key reasoning points (3-5 bullet points)"
+    },
+    rebuttals: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          concern: { type: "string" },
+          response: { type: "string" }
+        },
+        required: ["concern", "response"]
+      },
+      description: "Responses to anticipated counterarguments"
+    },
+    verdict: {
+      type: "string",
+      description: "Final recommendation with confidence level"
+    }
+  },
+  required: ["agent_name", "position", "reasoning", "rebuttals", "verdict"]
+};
+
+// Define 3 council agents with different perspectives
+const COUNCIL_AGENTS: AgentConfig[] = [
+  {
+    name: "Correctness Advocate",
+    provider: "claude",
+    model: "claude-sonnet-4-5",
+    enabled: true,
+    system_prompt: `You are the Correctness Advocate in this architectural council.
+
+YOUR MANDATE: Prioritize system correctness and data integrity above all else.
+
+EVALUATION CRITERIA:
+- What happens if timing assumptions break?
+- Can the system enter invalid states?
+- Are there race conditions or ordering dependencies?
+- What's the blast radius of bugs in each approach?
+- Which approach has fewer failure modes?
+
+STYLE:
+- Be skeptical of "it should work" assumptions
+- Point out edge cases and failure scenarios
+- Ask "what breaks when X happens before Y?"
+- Favor defensive, fail-safe designs`
+  },
+  {
+    name: "Simplicity Champion",
+    provider: "claude",
+    model: "claude-sonnet-4-5",
+    enabled: true,
+    system_prompt: `You are the Simplicity Champion in this architectural council.
+
+YOUR MANDATE: Advocate for the simplest solution that could possibly work.
+
+EVALUATION CRITERIA:
+- Which approach has fewer moving parts?
+- Can a new developer understand it in 5 minutes?
+- How many state transitions are required?
+- Is the responsibility of each component clear?
+- Which approach requires less documentation?
+
+STYLE:
+- Challenge unnecessary complexity
+- Prefer explicit over implicit behavior
+- Ask "do we really need this?"
+- Value readability and maintainability
+- Distrust "clever" solutions`
+  },
+  {
+    name: "Pragmatist",
+    provider: "claude",
+    model: "claude-sonnet-4-5",
+    enabled: true,
+    system_prompt: `You are the Pragmatist in this architectural council.
+
+YOUR MANDATE: Balance theoretical correctness with practical engineering constraints.
+
+EVALUATION CRITERIA:
+- What's the migration cost from current state?
+- How much code needs to change?
+- What's the testing burden?
+- Are there real-world scenarios that break each approach?
+- Which approach is easier to debug when things go wrong?
+
+STYLE:
+- Consider operational reality
+- Value incremental improvements over rewrites
+- Ask "what problem are we actually solving?"
+- Challenge both over-engineering and under-engineering
+- Focus on developer experience`
+  }
+];
+
+interface DebateResult {
+  agent_name: string;
+  position: string;
+  reasoning: string[];
+  rebuttals: Array<{ concern: string; response: string }>;
+  verdict: string;
+}
+
+async function runCouncilDebate(topic: string): Promise<void> {
+  logInfo("council", "Starting council debate");
+  console.log("\n=== COUNCIL DEBATE ===\n");
+  console.log(topic);
+  console.log("\n" + "=".repeat(80) + "\n");
+
+  const results: DebateResult[] = [];
+
+  // Run all agents in parallel
+  const promises = COUNCIL_AGENTS.map(async (agent) => {
+    logInfo("council", `Running agent: ${agent.name}`);
+
+    const result = await runAgentReview(
+      topic,
+      agent,
+      DEBATE_SCHEMA,
+      90000, // 90 second timeout
+      undefined,
+      "council-debate"
+    );
+
+    if (!result.ok) {
+      logError("council", `Agent ${agent.name} failed: ${result.error}`);
+      console.error(`\n[ERROR] ${agent.name} failed: ${result.error}\n`);
+      return null;
+    }
+
+    return result.normalized as unknown as DebateResult;
+  });
+
+  const responses = await Promise.all(promises);
+
+  // Filter out failed agents
+  for (const response of responses) {
+    if (response) {
+      results.push(response);
+    }
+  }
+
+  if (results.length === 0) {
+    console.error("\n[FATAL] All agents failed to respond\n");
+    process.exit(1);
+  }
+
+  // Display results
+  for (const result of results) {
+    console.log(`\n### ${result.agent_name}\n`);
+    console.log(`**Position:** ${result.position}\n`);
+
+    console.log("**Reasoning:**");
+    for (const point of result.reasoning) {
+      console.log(`- ${point}`);
+    }
+
+    if (result.rebuttals.length > 0) {
+      console.log("\n**Rebuttals:**");
+      for (const rebuttal of result.rebuttals) {
+        console.log(`- *${rebuttal.concern}*`);
+        console.log(`  → ${rebuttal.response}`);
+      }
+    }
+
+    console.log(`\n**Verdict:** ${result.verdict}\n`);
+    console.log("-".repeat(80));
+  }
+
+  // Compute consensus
+  console.log("\n=== CONSENSUS ANALYSIS ===\n");
+
+  const positionCounts = new Map<string, number>();
+  for (const result of results) {
+    positionCounts.set(result.position, (positionCounts.get(result.position) || 0) + 1);
+  }
+
+  console.log("**Position Distribution:**");
+  for (const [position, count] of positionCounts.entries()) {
+    console.log(`- ${position}: ${count}/${results.length} agents`);
+  }
+
+  const majorityPosition = Array.from(positionCounts.entries())
+    .sort((a, b) => b[1] - a[1])[0];
+
+  if (majorityPosition[1] >= 2) {
+    console.log(`\n**Majority Decision:** ${majorityPosition[0]} (${majorityPosition[1]}/${results.length} agents)`);
+  } else {
+    console.log("\n**No clear majority** - further investigation needed");
+  }
+
+  console.log("\n" + "=".repeat(80) + "\n");
+  logInfo("council", "Debate complete");
+}
+
+// Read debate topic from args or stdin
+const args = process.argv.slice(2);
+let topic: string;
+
+if (args.length > 0) {
+  topic = args.join(" ");
+} else {
+  // Read from stdin (pipe mode)
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  topic = Buffer.concat(chunks).toString("utf-8").trim();
+}
+
+if (!topic) {
+  console.error("Usage: council_debate.ts <topic> OR echo '<topic>' | council_debate.ts");
+  process.exit(1);
+}
+
+runCouncilDebate(topic).catch((e) => {
+  logError("council", `Fatal error: ${e}`);
+  console.error(`\n[FATAL] ${e}\n`);
+  process.exit(1);
+});

package/dist/templates/cc-native/_cc-native/scripts/council_debate_simple.ts

@@ -0,0 +1,294 @@
+#!/usr/bin/env bun
+/**
+ * Simplified council debate runner - bypasses review infrastructure.
+ * Directly invokes claude CLI and parses debate-specific schema.
+ */
+
+import { spawn } from "child_process";
+import { shellQuoteWin } from "../../_core/lib-ts/runtime/subprocess-utils.js";
+
+const DEBATE_SCHEMA = {
+  type: "object",
+  properties: {
+    agent_name: { type: "string" },
+    position: {
+      type: "string",
+      enum: ["approach_a", "approach_b", "hybrid", "neither"],
+    },
+    reasoning: {
+      type: "array",
+      items: { type: "string" },
+    },
+    rebuttals: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          concern: { type: "string" },
+          response: { type: "string" },
+        },
+        required: ["concern", "response"],
+      },
+    },
+    verdict: { type: "string" },
+  },
+  required: ["agent_name", "position", "reasoning", "rebuttals", "verdict"],
+};
+
+const AGENTS = [
+  {
+    name: "Correctness Advocate",
+    system: `You are the Correctness Advocate in this architectural council.
+
+YOUR MANDATE: Prioritize system correctness and data integrity above all else.
+
+EVALUATION CRITERIA:
+- What happens if timing assumptions break?
+- Can the system enter invalid states?
+- Are there race conditions or ordering dependencies?
+- What's the blast radius of bugs in each approach?
+- Which approach has fewer failure modes?
+
+STYLE:
+- Be skeptical of "it should work" assumptions
+- Point out edge cases and failure scenarios
+- Ask "what breaks when X happens before Y?"
+- Favor defensive, fail-safe designs`,
+  },
+  {
+    name: "Simplicity Champion",
+    system: `You are the Simplicity Champion in this architectural council.
+
+YOUR MANDATE: Advocate for the simplest solution that could possibly work.
+
+EVALUATION CRITERIA:
+- Which approach has fewer moving parts?
+- Can a new developer understand it in 5 minutes?
+- How many state transitions are required?
+- Is the responsibility of each component clear?
+- Which approach requires less documentation?
+
+STYLE:
+- Challenge unnecessary complexity
+- Prefer explicit over implicit behavior
+- Ask "do we really need this?"
+- Value readability and maintainability
+- Distrust "clever" solutions`,
+  },
+  {
+    name: "Pragmatist",
+    system: `You are the Pragmatist in this architectural council.
+
+YOUR MANDATE: Balance theoretical correctness with practical engineering constraints.
+
+EVALUATION CRITERIA:
+- What's the migration cost from current state?
+- How much code needs to change?
+- What's the testing burden?
+- Are there real-world scenarios that break each approach?
+- Which approach is easier to debug when things go wrong?
+
+STYLE:
+- Consider operational reality
+- Value incremental improvements over rewrites
+- Ask "what problem are we actually solving?"
+- Challenge both over-engineering and under-engineering
+- Focus on developer experience`,
+  },
+];
+
+interface DebateResult {
+  agent_name: string;
+  position: string;
+  reasoning: string[];
+  rebuttals: Array<{ concern: string; response: string }>;
+  verdict: string;
+}
+
+async function runAgent(
+  topic: string,
+  agentName: string,
+  systemPrompt: string,
+): Promise<DebateResult | null> {
+  return new Promise((resolve) => {
+    const schemaJson = JSON.stringify(DEBATE_SCHEMA);
+    const promptText = `IMMEDIATELY call StructuredOutput with your council debate response.
+Do NOT output any text before calling StructuredOutput.
+
+TOPIC:
+<<<
+${topic}
+>>>
+`;
+
+    const args = [
+      "--model",
+      "claude-sonnet-4-5",
+      "--output-format",
+      "json",
+      "--json-schema",
+      shellQuoteWin(schemaJson),
+      "--max-turns",
+      "3",
+      "--setting-sources",
+      process.platform === "win32" ? '""' : "",
+      "-p",
+      "--no-session-persistence",
+      "--system-prompt",
+      shellQuoteWin(systemPrompt),
+    ];
+
+    const claudeCmd = process.platform === "win32"
+      ? "C:\\Users\\fujos\\AppData\\Roaming\\npm\\claude.cmd"
+      : "claude";
+
+    console.error(`\n[${agentName}] Starting...`);
+
+    const proc = spawn(claudeCmd, args, {
+      shell: true,
+      env: {
+        ...process.env,
+        CLAUDECODE: undefined,
+        CLAUDE_CODE_ENTRYPOINT: undefined,
+      },
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        console.error(`[${agentName}] Failed with exit code ${code}`);
+        console.error(`[${agentName}] stderr: ${stderr}`);
+        resolve(null);
+        return;
+      }
+
+      // Parse CLI wrapper output
+      try {
+        const wrapper = JSON.parse(stdout);
+        if (wrapper.type !== "result" || !wrapper.structured_output) {
+          console.error(`[${agentName}] No structured_output in wrapper`);
+          console.error(`[${agentName}] wrapper keys: ${Object.keys(wrapper).join(", ")}`);
+          resolve(null);
+          return;
+        }
+
+        const result = wrapper.structured_output as DebateResult;
+        console.error(`[${agentName}] ✓ Position: ${result.position}`);
+        resolve(result);
+      } catch (e) {
+        console.error(`[${agentName}] Parse error: ${e}`);
+        console.error(`[${agentName}] stdout: ${stdout.slice(0, 500)}`);
+        resolve(null);
+      }
+    });
+
+    // Send prompt to stdin
+    proc.stdin?.write(promptText);
+    proc.stdin?.end();
+  });
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let topic: string;
+
+  if (args.length > 0) {
+    topic = args.join(" ");
+  } else {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    topic = Buffer.concat(chunks).toString("utf-8").trim();
+  }
+
+  if (!topic) {
+    console.error("Usage: council_debate_simple.ts <topic>");
+    process.exit(1);
+  }
+
+  console.log("\n=== COUNCIL DEBATE ===\n");
+  console.log(topic.slice(0, 200) + "...\n");
+  console.log("=".repeat(80) + "\n");
+
+  // Run all agents in parallel
+  const promises = AGENTS.map((agent) =>
+    runAgent(topic, agent.name, agent.system),
+  );
+
+  const results = (await Promise.all(promises)).filter(
+    (r): r is DebateResult => r !== null,
+  );
+
+  if (results.length === 0) {
+    console.error("\n[FATAL] All agents failed\n");
+    process.exit(1);
+  }
+
+  // Display results
+  for (const result of results) {
+    console.log(`\n### ${result.agent_name}\n`);
+    console.log(`**Position:** ${result.position}\n`);
+
+    console.log("**Reasoning:**");
+    for (const point of result.reasoning) {
+      console.log(`- ${point}`);
+    }
+
+    if (result.rebuttals.length > 0) {
+      console.log("\n**Rebuttals:**");
+      for (const rebuttal of result.rebuttals) {
+        console.log(`- *${rebuttal.concern}*`);
+        console.log(`  → ${rebuttal.response}`);
+      }
+    }
+
+    console.log(`\n**Verdict:** ${result.verdict}\n`);
+    console.log("-".repeat(80));
+  }
+
+  // Compute consensus
+  console.log("\n=== CONSENSUS ANALYSIS ===\n");
+
+  const positionCounts = new Map<string, number>();
+  for (const result of results) {
+    positionCounts.set(
+      result.position,
+      (positionCounts.get(result.position) || 0) + 1,
+    );
+  }
+
+  console.log("**Position Distribution:**");
+  for (const [position, count] of positionCounts.entries()) {
+    console.log(`- ${position}: ${count}/${results.length} agents`);
+  }
+
+  const majorityPosition = Array.from(positionCounts.entries()).sort(
+    (a, b) => b[1] - a[1],
+  )[0];
+
+  if (majorityPosition && majorityPosition[1] >= 2) {
+    console.log(
+      `\n**Majority Decision:** ${majorityPosition[0]} (${majorityPosition[1]}/${results.length} agents)`,
+    );
+  } else {
+    console.log("\n**No clear majority** - further investigation needed");
+  }
+
+  console.log("\n" + "=".repeat(80) + "\n");
+}
+
+main().catch((e) => {
+  console.error(`\n[FATAL] ${e}\n`);
+  process.exit(1);
+});

package/dist/templates/cc-native/_cc-native/{plan-review/workflows → workflows}/specdev.md

@@ -1,9 +1,9 @@
-Read this spec and interview me in detail using the AskUserQuestionTool about literally anything: 
-- Technical implementation
-- UI & UX
-- Concerns
-- Tradeoffs, etc. 
-
-But make sure the questions are not obvious
-
-Be very in-depth and continue interviewing me continually until it's complete, then write the spec to the file.
+Read this spec and interview me in detail using the AskUserQuestionTool about literally anything: 
+- Technical implementation
+- UI & UX
+- Concerns
+- Tradeoffs, etc. 
+
+But make sure the questions are not obvious
+
+Be very in-depth and continue interviewing me continually until it's complete, then write the spec to the file.

package/dist/templates/core/.claude/skills/codex/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: codex
+description: Delegate implementation to Codex sub-agents. USE WHEN codex OR send to codex OR codex implement OR hand off to codex OR launch codex OR run codex.
+user-invocable: true
+---
+
+# /codex
+
+Delegate work to a Codex sub-agent. The launch script handles prompt construction internally — you just run the command and pass the mode/flags.
+
+**IMPORTANT:** Never include the launch command path, script path, or any `.aiwcli/` internal paths in the delegation prompt or inline text arguments. The script constructs Codex's prompt internally. Leaking internal paths into the prompt causes Codex to recurse.
+
+## Command
+
+`bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/codex/scripts/launch-codex.ts [flags] <mode>`
+
+**Modes:** `plan` | `--file <path>` | `<inline text...>`
+
+**Flags:** `--model <name>`, `--sandbox <mode>`, `--context <id>`, `--prompt <text>`, `--no-yolo`, `--no-watch`
+
+## Usage
+
+Run with `run_in_background: true`. The script blocks until Codex exits and prints a session summary.
+
+For detailed delegation patterns (parallel, one-shot, ad-hoc), read `.aiwcli/_core/skills/codex/SKILL.md`.

package/dist/templates/core/.claude/skills/devin/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: devin
+description: Delegate implementation to Devin sub-agents. USE WHEN devin OR send to devin OR devin implement OR hand off to devin OR launch devin OR run devin.
+user-invocable: true
+---
+
+# /devin
+
+Delegate work to a Devin sub-agent. The launch script handles prompt construction internally — you just run the command and pass the mode/flags.
+
+**IMPORTANT:** Never include the launch command path, script path, or any `.aiwcli/` internal paths in the delegation prompt or inline text arguments. The script constructs Devin's prompt internally. Leaking internal paths into the prompt causes Devin to recurse.
+
+## Command
+
+`bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts [flags] <mode>`
+
+**Modes:** `plan` | `--file <path>` | `<inline text...>`
+
+**Flags:** `--model <name>`, `--context <id>`, `--prompt <text>`, `--no-watch`
+
+## Usage
+
+Run with `run_in_background: true`. The script blocks until Devin exits and prints a session summary.
+
+For detailed delegation patterns (parallel, one-shot, ad-hoc), read `.aiwcli/_core/skills/devin/SKILL.md`.

package/dist/templates/core/.claude/skills/handoff/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: handoff
+description: Create handoff document to preserve session context for future sessions. USE WHEN handoff OR write a handoff OR create session summary OR document what we did OR end session with notes.
+user-invocable: true
+---
+
+# /handoff
+
+Load and execute the handoff workflow from `.aiwcli/_core/skills/handoff-system/workflows/handoff.md`.
+
+**Triggers:** "/handoff", "write a handoff", "create a session summary", "document what we did", "end session with notes"

package/dist/templates/core/.claude/skills/handoff-resume/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: handoff-resume
+description: Resume session from a handoff document. USE WHEN resume handoff OR continue from handoff OR restore session context OR pick up where we left off.
+user-invocable: true
+---
+
+# /handoff-resume
+
+Load and execute the handoff resume workflow from `.aiwcli/_core/skills/handoff-system/workflows/handoff-resume.md`.
+
+**Triggers:** "/handoff-resume", "resume handoff", "continue from handoff", "restore session", "pick up where we left off"

package/dist/templates/core/.claude/skills/meta-plan/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: meta-plan
+description: Prompt amplifier for complex problems. USE WHEN meta-plan OR chain reasoning OR dissect problem OR help me figure out the right approach.
+user-invocable: true
+---
+
+# /meta-plan -- Prompt Amplifier
+
+Load and engage with the reasoning framework at `.aiwcli/_core/skills/meta-plan/workflows/meta-plan.md`. Apply each category as a lens for deeper analysis -- not as steps to execute.
+
+**Triggers:** "meta-plan", "chain reasoning", "dissect problem", "help me figure out the right approach"
+
+**Produces:** An amplified request document (problem decomposition, approaches, trade-offs, risks, recommendation). Does NOT produce implementation steps -- those are the next session's job.

package/dist/templates/core/.codex/skills/codex/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: codex
+description: "Self-reference guard: you ARE Codex. Do not invoke this skill."
+user-invocable: false
+---
+
+# Codex (Self-Reference Guard)
+
+**You are already running as Codex.** Do not attempt to launch another Codex instance.
+
+If asked to delegate work to Codex, you should perform the work directly — you are the Codex agent.
+
+To delegate to a *different* agent, use the devin skill instead.

package/dist/templates/core/.codex/skills/devin/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: devin
+description: Delegate implementation to Devin sub-agents. USE WHEN devin OR send to devin OR devin implement OR hand off to devin OR launch devin OR run devin.
+user-invocable: true
+---
+
+# Devin Workflow
+
+Delegate work to a Devin sub-agent. The launch script handles prompt construction internally — you just run the command and pass the mode/flags.
+
+**IMPORTANT:** Never include the launch command path, script path, or any `.aiwcli/` internal paths in the delegation prompt or inline text arguments. The script constructs Devin's prompt internally. Leaking internal paths into the prompt causes Devin to recurse.
+
+## Command
+
+`bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_core/skills/devin/scripts/launch-devin.ts [flags] <mode>`
+
+**Modes:** `plan` | `--file <path>` | `<inline text...>`
+
+**Flags:** `--model <name>`, `--context <id>`, `--prompt <text>`, `--no-watch`

package/dist/templates/core/.codex/skills/handoff/SKILL.md

@@ -0,0 +1,11 @@
+---
+name: handoff
+description: Create handoff document to preserve session context for future sessions. USE WHEN handoff OR write a handoff OR create session summary OR document what we did OR end session with notes.
+user-invocable: true
+---
+
+# Handoff
+
+Load and execute the handoff workflow from `.aiwcli/_core/skills/handoff-system/workflows/handoff.md`.
+
+**Triggers:** "/handoff", "write a handoff", "create a session summary", "document what we did", "end session with notes"