xcoder-origin 0.0.0-stage → 1.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neural Node Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+<!-- xcoder:version 2 | xcoder:task task-691585 | xcoder:updated 2026-11-05T05:49:47.429Z | xcoder:subtask code-st-b5251b -->
+# Xcoder SDLC
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A **SDLC-aware, ReAct-driven multi-agent CLI.** One Master
+Orchestrator, a swarm of role-mapped Sub Agents, and a workspace index as
+the LLM's source of truth for what files actually exist.  It classifies
+your task into a full SDLC pipeline, dispatches concurrent agents,
+validates every deliverable independently, and heals or escalates on
+failure — all without ever crashing on a subordinate's error.
+
+## Quick start
+
+```bash
+# Prerequisites: Node.js ≥ 20 and an Anthropic API key
+export ANTHROPIC_API_KEY=sk-ant-...
+
+# Install and run
+npm install -g xcoder-sdlc-cli
+xcoder --help
+
+# Or, clone and build (for contributors)
+git clone https://github.com/org/xcoder-sdlc-cli.git && cd xcoder-sdlc-cli
+npm install && npm run build && npm link
+xcoder write code for a JWT auth endpoint
+
+# unlink 
+npm uninstall -g xcoder-sdlc-cli
+```
+
+Xcoder SDLC is a pure command-line tool: there is no web UI, HTTP
+server or WebSocket endpoint, so nothing listens on a network port.
+
+Configure the LLM once with `xcoder --config "provider=deepseek,key=<your-key>"` (saved to `~/.xcoder/config.json`).
+
+> **[SETUP.md](docs/SETUP.md)** covers two installation paths (npm global
+> and clone-and-build) with verification steps and environment variable
+> configuration.
+
+## Agent CLIs
+
+The aggregator routes each top-level command name to the agent that owns it: `xcoder` and `ba-v1` to the SDLC agent, `bugfinder` to the QA agent, `litebro` to the litebro planner, `samurai-v1` / `genesis-v1` / `worker-v1` to the persona CLIs, and `jarvis` to jarvis.
+
+`jarvis` is delegated: `xcoder jarvis [args...]` runs the jarvis binary in a child process and forwards every argument unchanged, so `xcoder jarvis --chat` is an ordinary jarvis chat session. Exit codes are jarvis's own, plus `127` when the binary is missing and `130` when the run was interrupted. See [DELEGATION.md](https://github.com/org/xcoder-sdlc/blob/main/docs/DELEGATION.md).
+
+## Feature highlights
+
+- **[Business Analyst one-shot](./docs/USAGE.md#business-analyst-one-shot)** —
+  `xcoder --ba` accepts three input modes (file, directory, or bare title)
+  and produces a structured technical requirements document with numbered
+  acceptance criteria.
+- **[CLI with crash isolation and healing](./docs/USAGE.md#crash-isolation)** —
+  Sub Agent failures never take down the orchestrator.  Bounded healing
+  retries failures; exhausted attempts escalate clearly so you can resume
+  later.
+- **[Bounded benchmarking](./docs/USAGE.md#benchmarking)** — `xcoder bench` runs
+  real fixture sets through the live orchestrator and model, producing
+  per-fixture scores and comparative reports.
+- **[Sprint framework with quality gates](./docs/USAGE.md#sprint-framework)** —
+  `xcoder sprint start` builds a DAG pipeline interleaved with Scrum
+  Master, System Architect, and Security Lead quality gates that can block
+  the sprint before downstream stages waste tokens.
+- **[QA agent — requirement-to-coverage testing](./docs/QA_AGENT.md#4-usage)** —
+  author-owned `REQ-*` requirements become Playwright specs and are gated;
+  a requirement with no passing tagged test fails the run.
+
+## Architecture
+
+```
+  xcoder -task "..."
+       │
+       ▼
+  ┌─────────────────┐     ┌──────────────────┐
+  │  Task Factory    │────►│ SDLC Orchestrator │
+  │  (classifies     │     │ (DAG execution,    │
+  │   intake, builds │     │  validate, heal,   │
+  │   initial DAG)   │     │  escalate)         │
+  └─────────────────┘     └────────┬───────────┘
+                                   │ ready nodes
+                          ┌────────▼───────────┐
+                          │  Swarm dispatcher   │
+                          │  (N concurrent Sub  │
+                          │   Agents, isolated) │
+                          └────────┬───────────┘
+                                   │
+              ┌────────────────────┼────────────────────┐
+         ┌────▼────┐          ┌────▼────┐          ┌────▼────┐
+         │Sub Agent│          │Sub Agent│          │Sub Agent│
+         │(react   │          │(react   │          │(react   │
+         │ loop)   │          │ loop)   │          │ loop)   │
+         └────┬────┘          └────┬────┘          └────┬────┘
+              └────────────────────┼────────────────────┘
+                          ┌────────▼───────────┐
+                          │   Tool Registry     │
+                          │   + Workspace Index │
+                          └────────────────────┘
+```
+
+→ **[blueprint.md](./docs/blueprint.md)** for the full architecture reference:
+component decomposition, ReAct protocol contract, SDLC stage pipeline,
+Instance Swarm protocol, data flow, technology stack, tradeoffs, and
+internals (logging, benchmarking, scoring, validation, healing,
+credentials, environment awareness).
+
+## Documentation
+
+| Document                                             | Audience | Contents |
+|------------------------------------------------------|---|---|
+| **[USAGE.md](./docs/USAGE.md)**                      | Users with Xcoder SDLC installed | Full CLI flag reference, workspace/backlog/sprint commands, benchmarking, BA one-shot, user-facing behaviour. |
+| **[SETUP.md](./docs/SETUP.md)**                      | Someone installing from scratch | Prerequisites, two installation paths, environment variables, verification, optional Playwright setup. |
+| **[blueprint.md](./docs/blueprint.md)**              | Contributors and developers | Architecture diagram, component decomposition (16+ src/ components), ReAct contract, SDLC pipeline, swarm protocol, data flow, tech stack, tradeoffs, internals. |
+| **[TESTING.md](./docs/TESTING.md)**                  | Contributors & developers | How to run narrow test subsets for fast iteration during development. |
+| **[SDLC_ORCHESTRATOR_REFERENCE.md](./docs/SDLC_ORCHESTRATOR_REFERENCE.md)** | Maintainers repairing or comparing Xcoder versions | Implemented process, flow, rules, validation, recovery limits, and behavior preservation checklist. |
+| **[SECURE_MODE.md](./docs/SECURE_MODE.md)**          | Security reviewers & maintainers | Prompt-injection threat model, defence-in-depth diagram, per-component verdicts, residual risk. |
+| **[PROMPT_INJECTION_HARDENING.md](./docs/PROMPT_INJECTION_HARDENING.md)** | Contributors adding an agent, tool or LLM call site | Integration guide: resolve secure mode, envelope untrusted text, screen input, guard tool calls, redact logs, checklist. |
+| **[other-clis.md](./docs/other-clis.md)**            | Users running ba / samurai / genesis / worker | Per-binary synopsis, options with defaults, exit codes, env vars, examples. |
+| **[QA_AGENT.md](./docs/QA_AGENT.md)**                | Users and contributors using or extending the QA agent | Five-stage pipeline, module map, stage data contracts, CLI + library usage, exit codes, failure classes, bounded autonomy, security posture, troubleshooting. |
+
+## License
+
+see [LICENSE](./LICENSE) for details.

package/dist/cli-genesis.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/dist/cli-genesis.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+// xcoder:version 2 | xcoder:task task-762833 | xcoder:updated 2026-11-05T05:21:29.498Z | xcoder:subtask code-st-bb4289
+import "dotenv/config";
+import { Command } from "commander";
+import path from "node:path";
+import { GenesisReActOrchestrator } from "xcoder-dna";
+import { getOrBuildIndex } from "xcoder-dna";
+import { log } from "xcoder-dna";
+import { maybePrintBanner } from "xcoder-dna";
+import { createSpinner } from "xcoder-dna";
+import { enableProtocolErrorLogging } from "xcoder-dna";
+import { enableToolErrorLogging } from "xcoder-dna";
+import { XCODER_VERSION } from "xcoder-dna";
+import * as readline from "node:readline";
+// ---------------------------------------------------------------------------
+// Colour helpers — same conventions as XcoderCLIController + design doc
+// ---------------------------------------------------------------------------
+const COLOURS = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    magenta: "\x1b[35m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+};
+function useColor() {
+    return process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+}
+function paint(code, text) {
+    return useColor() ? `${code}${text}${COLOURS.reset}` : text;
+}
+function dim(s) {
+    return paint(COLOURS.dim, s);
+}
+// ---------------------------------------------------------------------------
+// Spinner manager
+// ---------------------------------------------------------------------------
+let spinner = null;
+function ensureSpinner() {
+    if (!spinner) {
+        spinner = createSpinner("Genesis thinking…");
+    }
+    return spinner;
+}
+function stopSpinner(msg) {
+    if (spinner) {
+        spinner.stop(msg ?? "");
+        spinner = null;
+    }
+}
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+const program = new Command();
+program
+    .name("genesis")
+    .description("Genesis — a single-agent ReAct engine that can call an Instance Swarm to parallelize complex work. " +
+    "One goal, one agent, optional swarm.")
+    .version(XCODER_VERSION)
+    .argument("<goal>", "The goal / task for Genesis to accomplish")
+    .option("--model <name>", "LLM model name", process.env.LLM_MODEL || "gpt-4o")
+    .option("--max-tokens <n>", "Max completion tokens", (v) => parseInt(v, 10), parseInt(process.env.LLM_MAX_TOKENS || "4096", 10))
+    .option("--workspace <dir>", "Workspace root directory", process.cwd())
+    .option("--skills <list>", "Comma-separated skill labels to inject", "")
+    .option("--no-color", "Disable colour output", false)
+    .option("--lesson-learned", "Enable record_lesson tool and inject .xcoder/lesson.md context", false)
+    .option("--log-output <path>", "enable SQLite output logging for ReAct signals (also settable via XCODER_OUTPUT_DB env var)")
+    .action(async (goal, opts) => {
+    // Respect --no-color by setting NO_COLOR early
+    if (opts.noColor) {
+        process.env.NO_COLOR = "1";
+    }
+    const workspaceRoot = path.resolve(opts.workspace);
+    const skills = (opts.skills || "")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    // Optional diagnostics from parent CLI pattern
+    if (process.env.PROTOCOL_ERROR_LOG)
+        enableProtocolErrorLogging();
+    if (process.env.DEBUG_TOOLS)
+        enableToolErrorLogging();
+    // Initialize OutputHandler for ReAct signal logging
+    const logOutputPath = opts.logOutput ||
+        process.env.XCODER_OUTPUT_DB ||
+        undefined;
+    const { getOutputHandler: getOH } = await import("xcoder-dna");
+    const outputHandler = getOH({
+        printToTerminal: process.env.XCODER_OUTPUT_SILENT !== "1",
+        logToSqlite: !!logOutputPath,
+        dbPath: logOutputPath,
+    });
+    // Build index so the agent sees the workspace
+    const index = await getOrBuildIndex(workspaceRoot);
+    log.dim(`Workspace indexed: ${index.entries.length} files`);
+    const orchestrator = new GenesisReActOrchestrator({
+        skills,
+        agentName: "genesis",
+        directive: "You are Genesis — a single-agent ReAct engine. Use call_swarm to parallelize complex work.",
+        llmOptions: {
+            model: opts.model,
+            maxTokens: opts.maxTokens,
+        },
+        lessonLearned: opts.lessonLearned,
+    });
+    // -----------------------------------------------------------------------
+    // Wire up real-time event → coloured output + spinner
+    // -----------------------------------------------------------------------
+    let currentState = "IDLE";
+    orchestrator.on("state:change", (newState) => {
+        currentState = newState;
+        switch (newState) {
+            case "THINKING":
+                ensureSpinner();
+                break;
+            case "EXECUTING_TOOL":
+                // spinner update happens in action:start
+                break;
+            case "COMPLETED":
+                stopSpinner(paint(COLOURS.green, "Done."));
+                break;
+            case "FAILED":
+                stopSpinner(paint(COLOURS.red, "Failed."));
+                break;
+            case "PAUSED":
+                stopSpinner(dim("Paused…"));
+                break;
+        }
+    });
+    orchestrator.on("thought", (thought) => {
+        // Print thought while spinner is running
+        if (spinner) {
+            // ora doesn't have a reliable "write above spinner" on all terminals;
+            // stop/restart pattern is safest across platforms.
+            stopSpinner();
+        }
+        log.raw(paint(COLOURS.magenta, `[Thought]`) + ` ${thought}`);
+        outputHandler.thought(thought);
+        if (currentState === "THINKING") {
+            ensureSpinner();
+        }
+    });
+    orchestrator.on("action:start", (action) => {
+        stopSpinner();
+        log.raw(paint(COLOURS.yellow, `[Action]`) +
+            ` ${action.tool}` +
+            dim(` ${JSON.stringify(action.input).slice(0, 200)}`));
+        outputHandler.action(action.tool, action.input);
+        spinner = createSpinner(`Executing ${action.tool}…`);
+    });
+    orchestrator.on("action:end", (toolName, observation) => {
+        stopSpinner();
+        const obsStr = typeof observation === "string"
+            ? observation
+            : JSON.stringify(observation, null, 0);
+        const truncated = obsStr.length > 800 ? obsStr.slice(0, 800) + dim("… (truncated)") : obsStr;
+        // Check for crash/warning patterns in observation
+        const isError = (typeof observation === "object" &&
+            observation !== null &&
+            observation.ok === false) ||
+            obsStr.includes("CRASHED");
+        if (isError) {
+            log.raw(paint(COLOURS.red, `[CRASHED]`) + ` ${toolName}: ${truncated}`);
+            outputHandler.error(`${toolName}: ${obsStr.slice(0, 800)}`);
+        }
+        else {
+            log.raw(paint(COLOURS.cyan, `[Observation]`) + ` ${truncated}`);
+            outputHandler.observation(obsStr.slice(0, 800));
+        }
+        // Re-enable spinner if loop continues
+        if (currentState === "THINKING") {
+            spinner = createSpinner("Genesis thinking…");
+        }
+    });
+    orchestrator.on("paused", () => {
+        stopSpinner();
+        log.raw(dim("── Genesis paused (Ctrl+C again to quit) ──"));
+        // Interactive steering: read one line of user input
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(paint(COLOURS.yellow, "Steering input") +
+            dim(" (press Enter to resume, type guidance to inject): "), (answer) => {
+            rl.close();
+            if (answer.trim()) {
+                orchestrator.injectUserInput(answer.trim());
+            }
+            else {
+                // Resume without injection — the orchestrator handles this
+                // by simply continuing the loop (interruptPending already cleared
+                // by injectUserInput; for a pure resume we rely on the
+                // orchestrator's internal handling).
+                orchestrator.injectUserInput("");
+            }
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Run
+    // -----------------------------------------------------------------------
+    log.raw(dim("── Genesis starting ──") +
+        `\n${dim("Goal:")} ${goal}` +
+        `\n${dim("Model:")} ${opts.model}` +
+        `\n${dim("Workspace:")} ${workspaceRoot}`);
+    try {
+        const finalAnswer = await orchestrator.run(goal);
+        stopSpinner();
+        log.raw("");
+        log.raw(paint(COLOURS.green, "[final_answer]") + ` ${finalAnswer}`);
+        log.ok("Genesis completed successfully.");
+    }
+    catch (e) {
+        stopSpinner();
+        log.fail(`Genesis crashed: ${e.message}`);
+        log.raw(paint(COLOURS.red, "[CRASHED]") +
+            dim(" — Genesis agent threw unexpectedly. This should not happen; check the error above."));
+        process.exitCode = 1;
+    }
+});
+maybePrintBanner(process.argv);
+program.parse();

package/dist/cli-samurai.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import "dotenv/config";
+/**
+ * Read package.json from workspace root if present, extract name/version/
+ * scripts/dependencies, and format as a context block injected into the
+ * system prompt. Non-fatal if absent.
+ */
+export declare function readPackageJsonContext(root: string): Promise<string | null>;

package/dist/cli-samurai.js

@@ -0,0 +1,434 @@
+#!/usr/bin/env node
+// xcoder:version 3 | xcoder:task task-762833 | xcoder:updated 2026-11-05T05:21:26.007Z | xcoder:subtask code-st-bb4289
+// xcoder:version 3 | xcoder:task task-c49600 | xcoder:updated 2026-08-13T13:52:36.713Z | xcoder:subtask code-st-6d79ef
+import "dotenv/config";
+import { Command } from "commander";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { createLlmClient } from "xcoder-dna";
+import { SamuraiAgent } from "xcoder-dna";
+import { runDebate } from "xcoder-dna";
+import { writeReport } from "xcoder-dna";
+import { InstanceSwarmOrchestrator } from "xcoder-dna";
+import { getOrBuildIndex } from "xcoder-dna";
+import { log } from "xcoder-dna";
+import { maybePrintBanner } from "xcoder-dna";
+import { enableProtocolErrorLogging } from "xcoder-dna";
+import { enableToolErrorLogging } from "xcoder-dna";
+import { XCODER_VERSION } from "xcoder-dna";
+import { getOutputPaths } from "xcoder-dna";
+import { xcoderEvents } from "xcoder-dna";
+import { randomUUID } from "node:crypto";
+import { resolveLessonFlag, loadLessons, checkLessonFileSize } from "xcoder-dna";
+/**
+ * Read package.json from workspace root if present, extract name/version/
+ * scripts/dependencies, and format as a context block injected into the
+ * system prompt. Non-fatal if absent.
+ */
+export async function readPackageJsonContext(root) {
+    try {
+        const raw = await fs.readFile(path.join(root, "package.json"), "utf8");
+        const pkg = JSON.parse(raw);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const depNames = Object.keys(deps).sort();
+        const depLines = depNames.length
+            ? depNames.map((n) => `  ${n}: ${deps[n]}`).join("\n")
+            : "  (none)";
+        const scriptLines = pkg.scripts
+            ? Object.entries(pkg.scripts)
+                .map(([k, v]) => `  ${k}: ${v}`)
+                .join("\n")
+            : "  (none)";
+        return `
+## Project package.json
+- name: ${pkg.name ?? "(not set)"}
+- version: ${pkg.version ?? "(not set)"}
+- description: ${pkg.description ?? "(not set)"}
+- scripts:
+${scriptLines}
+- dependencies:
+${depLines}
+`.trim();
+    }
+    catch {
+        return null;
+    }
+}
+// ── Debate CLI renderer ──
+// Color-coded real-time output for debate events during `samurai ai-chat`.
+// Uses ANSI colors: Sumurai = amber (warm/gold), Ninj = cyan (cool/teal).
+// Falls back to text prefixes when NO_COLOR is set or stdout is not a TTY.
+const COLOR_DEB = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    amber: "\x1b[38;5;214m",
+    cyan: "\x1b[38;5;80m",
+    green: "\x1b[38;5;78m",
+    coral: "\x1b[38;5;203m",
+};
+function useColor() {
+    return process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+}
+function paintDeb(code, text) {
+    return useColor() ? `${code}${text}${COLOR_DEB.reset}` : text;
+}
+function renderDebateEvent(ev) {
+    const data = ev.data;
+    if (!data)
+        return;
+    const agent = data.agent ?? "?";
+    const color = agent === "Sumurai" ? COLOR_DEB.amber : COLOR_DEB.cyan;
+    const prefix = useColor() ? paintDeb(color, `[${agent}]`) : `[${agent}]`;
+    switch (ev.type) {
+        case "debate:intro": {
+            const topic = data.topic;
+            log.dim(`── Debate started ──`);
+            log.raw(`${paintDeb(COLOR_DEB.dim, "Topic:")} ${topic}`);
+            break;
+        }
+        case "debate:turn-start": {
+            const role = data.role;
+            const tn = data.turnNumber;
+            log.raw(`${prefix} ${paintDeb(COLOR_DEB.dim, `─ Turn ${tn} (${role}) ─`)}`);
+            break;
+        }
+        case "debate:agent-thought": {
+            const thought = data.thought ?? "";
+            log.raw(`${prefix} ${paintDeb(COLOR_DEB.dim, "Thought:")} ${thought}`);
+            break;
+        }
+        case "debate:agent-action": {
+            const tool = data.tool ?? "?";
+            const input = data.input;
+            const inputStr = typeof input === "string" ? input : JSON.stringify(input).slice(0, 120);
+            log.raw(`${prefix} ${paintDeb(COLOR_DEB.green, `Action · ${tool}`)} ${inputStr}`);
+            break;
+        }
+        case "debate:agent-observation": {
+            const ok = data.ok;
+            const observation = data.observation ?? "";
+            const statusIcon = ok ? paintDeb(COLOR_DEB.green, "✓") : paintDeb(COLOR_DEB.coral, "✗");
+            log.raw(`${prefix} ${paintDeb(COLOR_DEB.dim, "Observed:")} ${statusIcon} ${observation.slice(0, 200)}`);
+            break;
+        }
+        case "debate:agent-final": {
+            const summary = data.summary ?? "";
+            log.raw(`${prefix} ${paintDeb(COLOR_DEB.green, "Final:")} ${summary}`);
+            break;
+        }
+        case "debate:agent-tokens": {
+            const cum = data.cumulative;
+            if (cum) {
+                log.raw(`${prefix} ${paintDeb(COLOR_DEB.dim, `Tokens: ${cum.inputTokens} in / ${cum.outputTokens} out`)}`);
+            }
+            break;
+        }
+        case "debate:outro": {
+            const status = data.status;
+            const turns = data.turns;
+            log.raw("");
+            log.dim(`── Debate ended: ${status} (${turns} turns) ──`);
+            break;
+        }
+    }
+}
+/**
+ * Subscribe to xcoderEvents for debate:* events matching the given debateId,
+ * rendering each event in real-time to stdout. Returns an unsubscribe function.
+ */
+function subscribeDebateCli(debateId) {
+    const handler = (ev) => {
+        if (ev.type.startsWith("debate:") &&
+            ev.taskId === debateId) {
+            renderDebateEvent(ev);
+        }
+    };
+    xcoderEvents.on("event", handler);
+    return () => {
+        xcoderEvents.off("event", handler);
+    };
+}
+// ── CLI definition ──
+const program = new Command();
+program
+    .name("samurai")
+    .description("samurai — a standalone single-agent CLI with full tool suite access (File Management, OS, Security, Windows/Linux/Mac).")
+    .version(XCODER_VERSION);
+program
+    .command("chat", { isDefault: true })
+    .alias("-chat")
+    .description("Start an interactive REPL session with the samurai agent.")
+    .option("-m, --model <name>", "override the LLM model (default: env XCODER_MODEL or deepseek-chat)")
+    .option("-w, --workspace <dir>", "workspace root", process.cwd())
+    .option("--max-iterations <n>", "max ReAct loop iterations per turn", "200")
+    .option("--debug-protocol-error", "enable protocol error diagnostic logging (also settable via PROTOCOL_ERROR_LOG env var)")
+    .option("--debug-tools [path]", "enable tool-error diagnostic logging to tools.log (also settable via DEBUG_TOOLS env var)")
+    .option("--lesson-learned", "enable lesson-learned: agent can record lessons into .xcoder/lesson.md and prior lessons are injected into the prompt (also settable via XCODER_LESSON_LEARNED env var)")
+    .option("--no-lesson-learned", "explicitly disable lesson-learned")
+    .option("--log-output <path>", "enable SQLite output logging for ReAct signals (also settable via XCODER_OUTPUT_DB env var)")
+    .action(async (opts) => {
+    if (opts.protocolErrorLog || process.env.PROTOCOL_ERROR_LOG) {
+        enableProtocolErrorLogging();
+    }
+    if (opts.debugTools || process.env.DEBUG_TOOLS) {
+        const customPath = typeof opts.debugTools === "string" ? opts.debugTools : process.env.DEBUG_TOOLS;
+        enableToolErrorLogging(typeof customPath === "string" ? customPath : undefined);
+    }
+    // Initialize OutputHandler for ReAct signal logging
+    const logOutputPath = opts.logOutput ||
+        process.env.XCODER_OUTPUT_DB ||
+        undefined;
+    const { getOutputHandler } = await import("xcoder-dna");
+    getOutputHandler({
+        printToTerminal: process.env.XCODER_OUTPUT_SILENT !== "1",
+        logToSqlite: !!logOutputPath,
+        dbPath: logOutputPath,
+    });
+    const root = path.resolve(opts.workspace);
+    // Resolve lesson-learned
+    const lessonLearned = resolveLessonFlag(opts.lessonLearned, process.env);
+    let lessonContext;
+    if (lessonLearned) {
+        const warning = await checkLessonFileSize(root);
+        if (warning)
+            log.raw(warning);
+        lessonContext = await loadLessons(root);
+    }
+    // Ensure the workspace is indexed so the agent sees the file structure
+    await getOrBuildIndex(root);
+    const pkgCtx = await readPackageJsonContext(root);
+    let llm;
+    try {
+        llm = createLlmClient("orchestrator", { model: opts.model });
+    }
+    catch (e) {
+        log.fail(e.message);
+        process.exitCode = 1;
+        return;
+    }
+    const agent = new SamuraiAgent({
+        workspaceRoot: root,
+        llm,
+        maxIterations: parseInt(opts.maxIterations, 10),
+        model: opts.model,
+        packageJsonContext: pkgCtx,
+        protocolErrorLog: !!(opts.protocolErrorLog || process.env.PROTOCOL_ERROR_LOG),
+        lessonLearned,
+        lessonContext,
+    });
+    await agent.runChat();
+});
+program
+    .command("task <prompt...>")
+    .alias("-task")
+    .description("Run a one-shot task with the samurai agent. Provide the task prompt as arguments (quoted for multi-word).")
+    .option("-m, --model <name>", "override the LLM model (default: env XCODER_MODEL or deepseek-chat)")
+    .option("-w, --workspace <dir>", "workspace root", process.cwd())
+    .option("--max-iterations <n>", "max ReAct loop iterations", "200")
+    .option("--debug-protocol-error", "enable protocol error diagnostic logging (also settable via PROTOCOL_ERROR_LOG env var)")
+    .option("--debug-tools [path]", "enable tool-error diagnostic logging to tools.log (also settable via DEBUG_TOOLS env var)")
+    .option("--lesson-learned", "enable lesson-learned: agent can record lessons into .xcoder/lesson.md and prior lessons are injected into the prompt (also settable via XCODER_LESSON_LEARNED env var)")
+    .option("--no-lesson-learned", "explicitly disable lesson-learned")
+    .option("--log-output <path>", "enable SQLite output logging for ReAct signals (also settable via XCODER_OUTPUT_DB env var)")
+    .action(async (promptParts, opts) => {
+    if (opts.protocolErrorLog || process.env.PROTOCOL_ERROR_LOG) {
+        enableProtocolErrorLogging();
+    }
+    if (opts.debugTools || process.env.DEBUG_TOOLS) {
+        const customPath = typeof opts.debugTools === "string" ? opts.debugTools : process.env.DEBUG_TOOLS;
+        enableToolErrorLogging(typeof customPath === "string" ? customPath : undefined);
+    }
+    // Initialize OutputHandler for ReAct signal logging
+    const logOutputPath = opts.logOutput ||
+        process.env.XCODER_OUTPUT_DB ||
+        undefined;
+    const { getOutputHandler } = await import("xcoder-dna");
+    getOutputHandler({
+        printToTerminal: process.env.XCODER_OUTPUT_SILENT !== "1",
+        logToSqlite: !!logOutputPath,
+        dbPath: logOutputPath,
+    });
+    const root = path.resolve(opts.workspace);
+    const prompt = promptParts.join(" ");
+    // Resolve lesson-learned
+    const lessonLearned = resolveLessonFlag(opts.lessonLearned, process.env);
+    let lessonContext;
+    if (lessonLearned) {
+        const warning = await checkLessonFileSize(root);
+        if (warning)
+            log.raw(warning);
+        lessonContext = await loadLessons(root);
+    }
+    await getOrBuildIndex(root);
+    const pkgCtx = await readPackageJsonContext(root);
+    let llm;
+    try {
+        llm = createLlmClient("orchestrator", { model: opts.model });
+    }
+    catch (e) {
+        log.fail(e.message);
+        process.exitCode = 1;
+        return;
+    }
+    const agent = new SamuraiAgent({
+        workspaceRoot: root,
+        llm,
+        maxIterations: parseInt(opts.maxIterations, 10),
+        model: opts.model,
+        packageJsonContext: pkgCtx,
+        protocolErrorLog: !!(opts.protocolErrorLog || process.env.PROTOCOL_ERROR_LOG),
+        lessonLearned,
+        lessonContext,
+    });
+    log.dim(`samurai task: ${prompt}`);
+    const result = await agent.runOnce(prompt);
+    if (result.summary) {
+        log.ok(result.summary);
+    }
+    if (result.deliverable !== null && result.deliverable !== undefined) {
+        log.raw(JSON.stringify(result.deliverable, null, 2));
+    }
+    log.dim(`iterations: ${result.iterations}  files_touched: ${result.filesTouched.length}  tokens: ${result.tokenUsage.inputTokens} in / ${result.tokenUsage.outputTokens} out`);
+    if (result.crashed)
+        process.exitCode = 1;
+    else if (result.stuckLoop)
+        process.exitCode = 2;
+});
+program
+    .command("ai-chat <topic...>")
+    .alias("-ai-chat")
+    .description("Run a dual-AI debate between Sumurai and Ninj on the given topic. Writes a Markdown report.")
+    .option("-m, --model <name>", "override the LLM model (default: env XCODER_MODEL or deepseek-chat)")
+    .option("-w, --workspace <dir>", "workspace root", process.cwd())
+    .option("--max-exchanges <n>", "max debate exchanges (default: 20)", "20")
+    .option("-o, --output-dir <dir>", "output directory for the report (default: .reports/ai-chat/)")
+    .option("--debug-protocol-error", "enable protocol error diagnostic logging (also settable via PROTOCOL_ERROR_LOG env var)")
+    .option("--debug-tools [path]", "enable tool-error diagnostic logging to tools.log (also settable via DEBUG_TOOLS env var)")
+    .action(async (topicParts, opts) => {
+    if (opts.protocolErrorLog || process.env.PROTOCOL_ERROR_LOG) {
+        enableProtocolErrorLogging();
+    }
+    if (opts.debugTools || process.env.DEBUG_TOOLS) {
+        const customPath = typeof opts.debugTools === "string" ? opts.debugTools : process.env.DEBUG_TOOLS;
+        enableToolErrorLogging(typeof customPath === "string" ? customPath : undefined);
+    }
+    const root = path.resolve(opts.workspace);
+    const topic = topicParts.join(" ");
+    const outputDir = opts.outputDir
+        ? path.resolve(opts.outputDir)
+        : getOutputPaths({ cwd: root }).aiChatReportsDir();
+    const debateId = randomUUID();
+    await getOrBuildIndex(root);
+    let llm;
+    try {
+        llm = createLlmClient("orchestrator", { model: opts.model });
+    }
+    catch (e) {
+        log.fail(e.message);
+        process.exitCode = 1;
+        return;
+    }
+    log.dim(`ai-chat debate topic: ${topic}`);
+    log.dim(`max exchanges: ${opts.maxExchanges}`);
+    log.raw("");
+    // Subscribe to debate events for real-time color-coded output
+    const unsub = subscribeDebateCli(debateId);
+    const debateResult = await runDebate({
+        workspaceRoot: root,
+        llm,
+        topic,
+        maxExchanges: parseInt(opts.maxExchanges, 10),
+        model: opts.model,
+        debateId,
+    });
+    // Unsubscribe from debate events — report writing is synchronous from here
+    unsub();
+    log.raw("");
+    // Write report regardless of debate outcome
+    let reportPath;
+    try {
+        reportPath = await writeReport(debateResult, outputDir);
+    }
+    catch (e) {
+        log.fail(`failed to write report: ${e.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    log.ok(`report written: ${reportPath}`);
+    log.dim(`status: ${debateResult.status}  turns: ${debateResult.turns.length}  tokens: ${debateResult.totalTokenUsage.inputTokens} in / ${debateResult.totalTokenUsage.outputTokens} out`);
+    if (debateResult.status === "error") {
+        log.fail(debateResult.errorMessage ?? "debate failed");
+        process.exitCode = 1;
+    }
+});
+program
+    .command("swarm <goal...>")
+    .alias("-swarm")
+    .description("Run an instance swarm: multiple SubAgents dispatched concurrently against a goal, with a protocol section injected.")
+    .option("--protocol <name>", "protocol name (coder, tester, architect, ui-ux, secops, devops)")
+    .option("-m, --model <name>", "override the LLM model (default: env XCODER_MODEL or deepseek-chat)")
+    .option("-w, --workspace <dir>", "workspace root", process.cwd())
+    .option("--concurrency <n>", "number of concurrent SubAgents", "1")
+    .option("--max-iterations <n>", "max iterations per SubAgent", "200")
+    .action(async (goalParts, opts) => {
+    const root = path.resolve(opts.workspace);
+    const goal = goalParts.join(" ");
+    if (!opts.protocol) {
+        log.fail("--protocol is required (coder, tester, architect, ui-ux, secops, devops)");
+        process.exitCode = 1;
+        return;
+    }
+    await getOrBuildIndex(root);
+    let llm;
+    try {
+        llm = createLlmClient("orchestrator", { model: opts.model });
+    }
+    catch (e) {
+        log.fail(e.message);
+        process.exitCode = 1;
+        return;
+    }
+    const orchestrator = new InstanceSwarmOrchestrator({
+        workspaceRoot: root,
+        llm,
+        concurrency: parseInt(opts.concurrency, 10),
+        maxIterations: parseInt(opts.maxIterations, 10),
+    });
+    log.dim(`swarm goal: ${goal}`);
+    log.dim(`protocol: ${opts.protocol}  concurrency: ${opts.concurrency}`);
+    let swarmResult;
+    try {
+        swarmResult = await orchestrator.run(goal, opts.protocol);
+    }
+    catch (e) {
+        log.fail(`swarm orchestration failed: ${e.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    log.ok(`instanceId: ${swarmResult.instanceId}`);
+    log.dim(`status: ${swarmResult.status}`);
+    log.dim(`outputDir: ${swarmResult.outputDir}`);
+    log.dim(`errors: ${swarmResult.errors.length}  workers: ${swarmResult.results.length}  tokens: ${swarmResult.totalTokenUsage.inputTokens} in / ${swarmResult.totalTokenUsage.outputTokens} out`);
+    if (swarmResult.errors.length > 0) {
+        for (const err of swarmResult.errors) {
+            log.fail(err);
+        }
+    }
+    if (swarmResult.status === "failed") {
+        process.exitCode = 1;
+    }
+});
+// Also support `samurai -chat`, `samurai -task`, and `samurai -ai-chat` as top-level options
+// when no subcommand is given (Commander option-like routing).
+program
+    .option("-chat", "start interactive chat REPL")
+    .option("-task <prompt...>", "run one-shot task")
+    .option("-ai-chat <topic...>", "run dual-AI debate")
+    .option("-m, --model <name>", "override model")
+    .option("-w, --workspace <dir>", "workspace root", process.cwd())
+    .option("--max-iterations <n>", "max iterations", "200");
+maybePrintBanner(process.argv);
+program.parseAsync().catch((e) => {
+    log.fail(e.message);
+    process.exitCode = 1;
+});

package/dist/cli-worker.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/dist/cli-worker.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+// xcoder:version 2 | xcoder:task task-762833 | xcoder:updated 2026-11-05T05:21:32.402Z | xcoder:subtask code-st-bb4289
+// `worker` bin — generic (non-SDLC) task delegation.
+//
+// Deliberately minimal: parse, build one LLM client, run the orchestrator,
+// print the report. No stage flags, no healing flags, no steering, and no
+// spinner that could corrupt `--json` output.
+import "dotenv/config";
+import { Command } from "commander";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { createLlmClient } from "xcoder-dna";
+import { getOrBuildIndex } from "xcoder-dna";
+import { log } from "xcoder-dna";
+import { maybePrintBanner } from "xcoder-dna";
+import { enableProtocolErrorLogging } from "xcoder-dna";
+import { enableToolErrorLogging } from "xcoder-dna";
+import { XCODER_VERSION } from "xcoder-dna";
+import { WorkerOrchestrator } from "xcoder-dna";
+/** Usage errors exit 2 and never print a report. */
+class UsageError extends Error {
+}
+/** Normalises one input entry; ids default to `st-<n>` in order. */
+function normaliseSubtask(raw, index) {
+    const fallbackId = `st-${index + 1}`;
+    if (typeof raw === "string") {
+        const goal = raw.trim();
+        if (!goal)
+            throw new UsageError(`subtask ${fallbackId} has an empty goal`);
+        return { id: fallbackId, goal };
+    }
+    // JSON arrays may contain null/number/boolean entries; anything that is not
+    // an object is a usage error, exactly like an entry with an empty goal.
+    if (raw === null || typeof raw !== "object") {
+        throw new UsageError(`subtask ${fallbackId} must be a string or an object with a goal (got ${raw === null ? "null" : typeof raw})`);
+    }
+    const goal = typeof raw.goal === "string" ? raw.goal.trim() : "";
+    if (!goal)
+        throw new UsageError(`subtask ${fallbackId} has an empty goal`);
+    const id = typeof raw.id === "string" && raw.id.trim() ? raw.id.trim() : fallbackId;
+    const sub = { id, goal };
+    if (typeof raw.role === "string" && raw.role.trim())
+        sub.role = raw.role.trim();
+    if (typeof raw.deliverableSpec === "string" && raw.deliverableSpec.trim()) {
+        sub.deliverableSpec = raw.deliverableSpec;
+    }
+    if (raw.upstreamContext && typeof raw.upstreamContext === "object") {
+        sub.upstreamContext = raw.upstreamContext;
+    }
+    return sub;
+}
+/** Reads `--subtasks <file>` (JSON: string[] or {id,goal,role?}[]); "-" means stdin. */
+async function readSubtasksFile(spec) {
+    let raw;
+    try {
+        raw = spec === "-" ? await readStdin() : await fs.readFile(path.resolve(spec), "utf8");
+    }
+    catch (e) {
+        throw new UsageError(`could not read subtasks file '${spec}': ${e.message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new UsageError(`subtasks file '${spec}' is not valid JSON: ${e.message}`);
+    }
+    if (!Array.isArray(parsed))
+        throw new UsageError("subtasks file must contain a JSON array");
+    return parsed;
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let buf = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => (buf += chunk));
+        process.stdin.on("end", () => resolve(buf));
+        process.stdin.on("error", reject);
+    });
+}
+function printHuman(report) {
+    log.raw("");
+    log.orchestrator(`task ${report.taskId} — ${report.status}`);
+    for (const s of report.subtasks) {
+        const label = `${s.id} (${s.attempts} attempt${s.attempts === 1 ? "" : "s"})`;
+        if (s.status === "done") {
+            log.ok(`${label}: ${s.summary || "done"}`);
+        }
+        else {
+            log.fail(`${label}: ${s.error ?? "failed"}`);
+        }
+        for (const f of s.filesTouched)
+            log.dim(`    touched ${f}`);
+        for (const h of s.history) {
+            if (h.error)
+                log.dim(`    attempt ${h.attempt} failed: ${h.error}`);
+        }
+    }
+    log.dim(`${report.totals.done} done, ${report.totals.failed} failed, ` +
+        `${report.totals.totalAttempts} attempt(s), ` +
+        `${report.totals.inputTokens}/${report.totals.outputTokens} tokens, ` +
+        `${report.totals.durationMs}ms`);
+    for (const e of report.errors)
+        log.fail(`run error: ${e}`);
+}
+const program = new Command();
+program
+    .name("worker")
+    .description("Generic worker orchestrator for non-SDLC work: accepts a task description and a list of " +
+    "subtasks, spawns one worker agent per subtask, retries failures, and prints an aggregated report.")
+    .version(XCODER_VERSION);
+program
+    .command("run")
+    .description("Run a task by delegating its subtasks to worker agents")
+    .option("--task <text>", "Task description")
+    .option("--subtasks <file>", 'JSON file: string[] or {id,goal,role?}[]; "-" reads stdin')
+    .option("--subtask <goal>", "Repeatable single subtask (collector)", (v, acc) => {
+    acc.push(v);
+    return acc;
+}, [])
+    .option("--concurrency <n>", "Max in-flight workers", (v) => parseInt(v, 10), 3)
+    .option("--max-attempts <n>", "Total attempts per subtask", (v) => parseInt(v, 10), 2)
+    .option("--workspace <dir>", "Workspace root", process.cwd())
+    .option("--model <name>", "Overrides the configured LLM model")
+    .option("--task-id <id>", "Explicit run id")
+    .option("--json", "Machine output: the report only, no prose on stdout", false)
+    .option("--quiet", "Suppress progress notes", false)
+    .option("--no-color", "Disable colour output")
+    .action(async (opts) => {
+    if (!opts.color)
+        process.env.NO_COLOR = "1";
+    try {
+        // `--task` is validated here rather than with `requiredOption` so a
+        // missing value is a UsageError (exit 2), like every other usage error,
+        // instead of commander's own exit code 1.
+        if (typeof opts.task !== "string" || !opts.task.trim()) {
+            throw new UsageError("required option '--task <text>' not specified");
+        }
+        // ---- collect inputs -------------------------------------------------
+        const rawFromFile = opts.subtasks ? await readSubtasksFile(opts.subtasks) : [];
+        const rawAll = [
+            ...rawFromFile,
+            ...(opts.subtask ?? []).map((g) => g),
+        ];
+        if (rawAll.length === 0) {
+            throw new UsageError("no subtasks given; pass --subtasks <file> or at least one --subtask <goal>");
+        }
+        const subtasks = rawAll.map((raw, i) => normaliseSubtask(raw, i));
+        const workspaceRoot = path.resolve(opts.workspace);
+        // ---- build the client and warm the index (best-effort) ----------------
+        const llm = createLlmClient("sub_agent", opts.model ? { model: opts.model } : {});
+        try {
+            await getOrBuildIndex(workspaceRoot);
+        }
+        catch (e) {
+            if (!opts.json)
+                log.dim(`workspace index unavailable: ${e.message}`);
+        }
+        enableProtocolErrorLogging();
+        enableToolErrorLogging();
+        // ---- run -------------------------------------------------------------
+        const report = await new WorkerOrchestrator({
+            workspaceRoot,
+            llm,
+            quiet: opts.quiet ?? false,
+        }).run({
+            taskDescription: opts.task,
+            subtasks,
+            concurrency: opts.concurrency,
+            maxAttempts: opts.maxAttempts,
+            taskId: opts.taskId,
+            signal: makeSignal(),
+        });
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+        }
+        else {
+            printHuman(report);
+        }
+        process.exitCode = report.status === "failed" ? 1 : 0;
+    }
+    catch (e) {
+        if (opts.json) {
+            // Machine mode: stdout carries ONLY the JSON document so consumers can
+            // pipe straight into JSON.parse/jq. Diagnostics go to stderr.
+            process.stdout.write(JSON.stringify({ error: e.message, usage: e instanceof UsageError }, null, 2) + "\n");
+            process.stderr.write(`worker: ${e.message}\n`);
+        }
+        else {
+            log.fail(e.message);
+        }
+        process.exitCode = e instanceof UsageError ? 2 : 1;
+    }
+});
+/** Ctrl+C aborts *new* waves; in-flight agents finish naturally. */
+function makeSignal() {
+    const controller = new AbortController();
+    process.once("SIGINT", () => controller.abort());
+    return controller.signal;
+}
+maybePrintBanner(process.argv);
+program.parseAsync().catch((e) => {
+    log.fail(e?.message ?? String(e));
+    process.exitCode = 2;
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+/** Which agent owns which top-level command name. */
+export declare const DISPATCH: Record<string, (argv: string[]) => Promise<number>>;
+/** Combined help text listing every command that exists today. */
+export declare function renderHelp(): string;

package/dist/index.js

@@ -0,0 +1,26 @@
+// Aggregator public surface: argv dispatch across agents (design 4.6).
+import { runSdlcAgent } from "@xcoder/sdlc-agent";
+import { runQaAgent } from "@xcoder/qa-agent";
+import { runLitebro } from "@xcoder/litebro";
+/** Which agent owns which top-level command name. */
+export const DISPATCH = {
+    xcoder: runSdlcAgent,
+    "ba-v1": runSdlcAgent,
+    bugfinder: runQaAgent,
+    litebro: runLitebro,
+};
+/** Combined help text listing every command that exists today. */
+export function renderHelp() {
+    return [
+        "Xcoder SDLC - multi-agent CLI",
+        "",
+        "Commands:",
+        "  xcoder      SDLC agent (plan, implement, test, review)",
+        "  ba-v1       Business-analyst intake",
+        "  bugfinder   QA agent",
+        "  litebro     Tool-less planner/broker",
+        "  samurai-v1  Samurai persona",
+        "  genesis-v1  Genesis persona",
+        "  worker-v1   Worker persona",
+    ].join("\n");
+}

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "xcoder-origin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.4.1",
+  "description": "Xcoder SDLC — a SDLC-aware, ReAct-driven multi-agent CLI. One Master Orchestrator, a swarm of role-mapped Sub Agents, a workspace index as the source of truth.",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "samurai-v1": "./dist/cli-samurai.js",
+    "genesis-v1": "./dist/cli-genesis.js",
+    "worker-v1": "./dist/cli-worker.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "xcoder-dna": "^1.4.0",
+    "xcoder-jarvis-agent": "^1.4.0",
+    "xcoder-qa-agent": "^1.4.0",
+    "xcoder-litebro": "^1.4.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5"
+  }
 }