robisie 0.1.0 → 0.1.1

package/dist/attempt-identity.js

@@ -0,0 +1,39 @@
+export function classifyStart(input) {
+    const expected = input.attempt ?? input.seq; // P1-e: brak attempt → stary seq
+    if (!nonempty(input.jobId))
+        return { ok: false, reason: "brak jobId" };
+    if (!positiveInteger(input.attempts) || input.attempts !== expected)
+        return { ok: false, reason: "próba się nie zgadza" };
+    const active = input.actives.find(a => a.taskId === input.cardId);
+    if (!active)
+        return { ok: false, reason: "brak w state.actives" };
+    if (active.jobId !== input.jobId || active.attempts !== expected) {
+        return { ok: false, reason: "state.actives nie zgadza się z próbą/jobId" };
+    }
+    const status = typeof input.helperStatus === "string" ? input.helperStatus.trim().toLowerCase() : "";
+    if (status !== "queued" && status !== "running" && status !== "completed") {
+        return { ok: false, reason: `helper ${status || "brak"}` };
+    }
+    return { ok: true };
+}
+export function nextAttempt(details) {
+    const worker = details?.maszynista;
+    if (!record(worker))
+        return 1;
+    const previous = worker.attempts ?? worker.attempt;
+    if (worker.outcome === "MODEL_AT_CAPACITY" && positiveInteger(previous))
+        return previous;
+    // Karta po blokadzie wrocila do ready reka czlowieka/CR -> nowa seria prob (inaczej 4/3 = blokada po 1 probie).
+    if (worker.move === "blocked")
+        return 1;
+    return positiveInteger(previous) ? previous + 1 : 1;
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function nonempty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/ci-failure-result.d.ts

@@ -0,0 +1,23 @@
+export type CiJobSteps = {
+    name: string;
+    diskTrusted?: boolean;
+    evidenceMissing?: boolean;
+    interruptedTrusted?: "cancelled" | "timed_out";
+    steps: Array<{
+        name: string;
+        conclusion: string | null;
+    }>;
+};
+export declare function failedTestFiles(raw: string): string[];
+export declare function normalizeCiLogTail(raw: string, maxLines?: number, maxChars?: number): string;
+export declare function formatCiFailNote(failed: Array<{
+    name: string;
+    conclusion: string | null;
+}>, jobs: CiJobSteps[], tails: Array<{
+    runId: string;
+    tail: string;
+}>, maxChars?: number): string;
+export declare const CI_DISK_HOLD_STEP = "Robisie disk HOLD v1";
+export declare const CI_DISK_HOLD_JOBS: string[];
+export declare function hasCiDiskHold(job: CiJobSteps): boolean;
+export declare function classifyCiFailure(failedJobs: CiJobSteps[]): "disk" | "host" | "infra" | "code" | "unknown";

package/dist/ci-failure-result.js

@@ -0,0 +1,90 @@
+export function failedTestFiles(raw) {
+    const clean = raw.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+    return [...new Set(Array.from(clean.matchAll(/(?:^|[\t ])FAIL[\t ]+([^\s]+\.test\.(?:ts|tsx|mts|mjs|js))[\t ]+(?:>|\[)/gm), match => match[1]))];
+}
+export function normalizeCiLogTail(raw, maxLines = 40, maxChars = 1000) {
+    const lines = raw.split(/\r?\n/).map((line) => line
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, "")
+        .replace(/^[^\t]*\t[^\t]*\t/, "")
+        .replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z\s?/, "")
+        .trimEnd()).filter((line) => line.trim().length > 0);
+    const tail = lines.slice(-maxLines).join("\n");
+    return tail.length > maxChars ? `…${tail.slice(-(maxChars - 1))}` : tail;
+}
+export function formatCiFailNote(failed, jobs, tails, maxChars = 1400) {
+    const header = `CI: ${failed.map((run) => `${run.name}: ${run.conclusion}`).join(", ")}`;
+    const steps = jobs.flatMap((job) => {
+        const failedSteps = job.steps.filter((step) => step.conclusion === "failure");
+        return failedSteps.length > 0 ? failedSteps.map((step) => `${job.name} › ${step.name}`) : [job.name];
+    });
+    const marker = "…(ucięto)";
+    if (header.length >= maxChars)
+        return header.slice(0, maxChars);
+    let note = header;
+    const nonEmptyTails = tails.filter(({ tail }) => tail.length > 0);
+    const firstTail = nonEmptyTails[0];
+    const firstBlock = firstTail ? `\n--- ogon logu run ${firstTail.runId} ---\n${firstTail.tail}` : "";
+    const tailReserve = Math.min(firstBlock.length, 500) + (nonEmptyTails.length > 1 ? marker.length : 0);
+    if (steps.length > 0) {
+        const stepLine = `\nPadłe: ${steps.join(", ")}`;
+        const stepBudget = maxChars - note.length - tailReserve;
+        const stepMarker = firstTail ? "…(ucięto kroki)" : marker;
+        if (stepLine.length <= stepBudget)
+            note += stepLine;
+        else if (stepBudget >= stepMarker.length)
+            note += `${stepLine.slice(0, stepBudget - stepMarker.length)}${stepMarker}`;
+    }
+    for (const [index, { runId, tail }] of nonEmptyTails.entries()) {
+        const blockHeader = `\n--- ogon logu run ${runId} ---\n`;
+        const block = `${blockHeader}${tail}`;
+        if (note.length + block.length > maxChars) {
+            if (index === 0) {
+                const omittedMarker = nonEmptyTails.length > 1 ? marker : "";
+                const tailRoom = maxChars - note.length - blockHeader.length - omittedMarker.length;
+                if (tailRoom > 1) {
+                    note += `${blockHeader}…${tail.slice(-(tailRoom - 1))}${omittedMarker}`;
+                    break;
+                }
+            }
+            if (note.length + marker.length <= maxChars)
+                note += marker;
+            break;
+        }
+        note += block;
+    }
+    return note;
+}
+export const CI_DISK_HOLD_STEP = "Robisie disk HOLD v1";
+export const CI_DISK_HOLD_JOBS = ["Verify (lint + build:check)", "Secret scan (gitleaks)", "check-agent-writes (ROB brief narrative discipline)", "check-postmortem-required (ROB_099 — bugfix postmortem gate)", "Deploy (wrangler → Cloudflare Workers)"];
+export function hasCiDiskHold(job) {
+    return job.diskTrusted === true && CI_DISK_HOLD_JOBS.includes(job.name)
+        && job.steps.some(step => step.name === CI_DISK_HOLD_STEP && step.conclusion === "failure");
+}
+export function classifyCiFailure(failedJobs) {
+    if (failedJobs.length === 0)
+        return "unknown";
+    const hostStep = /^(Set up runner|Complete runner|Set up job|Complete job)$/;
+    let sawFailedStep = false;
+    let sawNotStartedJob = false;
+    let sawDisk = false;
+    const diskPresent = failedJobs.some(hasCiDiskHold);
+    for (const job of failedJobs) {
+        if (job.evidenceMissing && job.interruptedTrusted && !diskPresent)
+            continue;
+        if (job.steps.length === 0 && !job.evidenceMissing)
+            sawNotStartedJob = true;
+        const failed = job.steps.filter((st) => st.conclusion === "failure");
+        if (failed.length === 0)
+            continue;
+        sawFailedStep = true;
+        const disk = hasCiDiskHold(job);
+        if (!failed.every((st) => hostStep.test(st.name) || disk && st.name === CI_DISK_HOLD_STEP))
+            return "code";
+        sawDisk ||= disk;
+    }
+    if (sawDisk)
+        return failedJobs.some(job => !job.interruptedTrusted && (job.evidenceMissing || job.steps.length > 0 && !job.steps.some(step => step.conclusion === "failure"))) ? "unknown" : "disk";
+    if (sawNotStartedJob)
+        return "infra";
+    return sawFailedStep ? "host" : "unknown";
+}

package/dist/claude-headless.d.ts

@@ -0,0 +1,7 @@
+export declare const HEADLESS_SYSTEM_PROMPT = "Jeste\u015B bezstanowym modu\u0142em fabryki Robisie wywo\u0142ywanym przez skrypt. Nie masz narz\u0119dzi ani dost\u0119pu do repozytorium, plik\u00F3w, tablicy ani historii \u2014 opierasz si\u0119 wy\u0142\u0105cznie na tre\u015Bci tej wiadomo\u015Bci. Odpowiadasz dok\u0142adnie w formacie, kt\u00F3rego \u017C\u0105da wiadomo\u015B\u0107.";
+export declare const HEADLESS_CLAUDE_ENV: {
+    readonly CLAUDE_CODE_DISABLE_ATTACHMENTS: "1";
+};
+export declare function headlessClaudeArgs(model: string): string[];
+/** Tokeny wejścia z koperty `--output-format json`; null, gdy koperta nie ma liczbowego `usage`. */
+export declare function envelopeInputTokens(envelope: unknown): number | null;

package/dist/claude-headless.js

@@ -0,0 +1,28 @@
+// Jedno źródło argumentów `claude -p` dla automatu (selektor, agent zasiewu).
+// Po co (Reksio-364, 2026-09-22, zmierzone): `--allowedTools ""` NIE odbiera narzędzi, a
+// `--exclude-dynamic-system-prompt-sections` PRZENOSI `git status` do pierwszej wiadomości zamiast go
+// usuwać; z cwd = repo model dostawał też personę Reksia (CLAUDE.local.md) i hooki SessionStart —
+// 44 562 tokeny wejścia i 12 narzędzi. Z listą poniżej: 0 narzędzi, 0 instrukcji, 0 hooków, 1 234 tokeny.
+// `--bare` odpada: wymaga ANTHROPIC_API_KEY, a fabryka działa na OAuth (plan Max).
+export const HEADLESS_SYSTEM_PROMPT = "Jesteś bezstanowym modułem fabryki Robisie wywoływanym przez skrypt. Nie masz narzędzi ani dostępu do repozytorium, plików, tablicy ani historii — opierasz się wyłącznie na treści tej wiadomości. Odpowiadasz dokładnie w formacie, którego żąda wiadomość.";
+// --tools "" does not stop CLI-side @file expansion before the model sees the prompt.
+export const HEADLESS_CLAUDE_ENV = { CLAUDE_CODE_DISABLE_ATTACHMENTS: "1" };
+export function headlessClaudeArgs(model) {
+    return [
+        "-p", "--model", model, "--disable-slash-commands",
+        "--tools", "", "--setting-sources", "", "--strict-mcp-config",
+        "--system-prompt", HEADLESS_SYSTEM_PROMPT, "--output-format", "json",
+    ];
+}
+const TOKEN_FIELDS = ["input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"];
+/** Tokeny wejścia z koperty `--output-format json`; null, gdy koperta nie ma liczbowego `usage`. */
+export function envelopeInputTokens(envelope) {
+    if (typeof envelope !== "object" || envelope === null)
+        return null;
+    const usage = envelope.usage;
+    if (typeof usage !== "object" || usage === null)
+        return null;
+    const values = TOKEN_FIELDS.map((field) => usage[field])
+        .filter((value) => typeof value === "number");
+    return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0);
+}

package/dist/cli.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { type AgentId } from "./agents.js";
+import { type Ctx } from "./context.js";
+import { type RoleProviders } from "./manifest.js";
+export interface ParsedArgs {
+    command: string;
+    help: boolean;
+    /** Positional argument (`robisie mcp <name>`). */
+    target: string | null;
+    agents: AgentId[] | null;
+    roles: Partial<RoleProviders>;
+    shell: boolean;
+    keyStdin: boolean;
+    engineConfig: string | null;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+export declare function run(argv: readonly string[], ctx: Ctx): Promise<number>;

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { AGENT_IDS, isAgentId } from "./agents.js";
-import { doctor, init, uninstall } from "./commands.js";
+import { doctor, init, recoveryStep, uninstall } from "./commands.js";
 import { HELPER_SERVERS, PACKAGE_VERSION } from "./constants.js";
 import { RobisieError, errorMessage, nodeCtx } from "./context.js";
-import { isHelperServer, runHelper } from "./helpers.js";
+import { helperPath, isHelperServer, runHelper } from "./helpers.js";
 import { ROLE_IDS, ROLE_STEP } from "./manifest.js";
+import { doctorEngineConfig } from "./role-registry.js";
 const HELP = `robisie ${PACKAGE_VERSION} — łączy Twojego agenta z tablicą robisie
 
   npx robisie init        klucz rob_… (z ${"ROBISIE_KEY"} albo z pytania) + konfiguracja MCP + role klienta
@@ -15,6 +16,10 @@ const HELP = `robisie ${PACKAGE_VERSION} — łączy Twojego agenta z tablicą r
   npx robisie mcp <${HELPER_SERVERS.join("|")}>
                           pomocnik ról (serwer MCP stdio) — uruchamia go agent, nie Ty
 
+Opcje doctor:
+  --engine-config <path>           lokalnie i offline sprawdza K2 i rejestr wykonania czterech ról K7
+  --engine-config=<path>           ta sama składnia; nie sprawdza uruchomienia dostawców
+
 Opcje init:
   --agent <${AGENT_IDS.join("|")}>   wybrany dostawca (można powtórzyć albo podać po przecinku); razem z dostawcami mapy, bez --agent również wykryci
   --role <rola=dostawca>           wybór ceo, builder, quality → claude, codex, opencode (można powtórzyć)
@@ -29,13 +34,30 @@ export function parseArgs(argv) {
     const roles = {};
     let shell = true;
     let keyStdin = false;
+    let engineConfig = null;
     let target = null;
     // Help wins over everything else, so `init --help` never starts an install.
-    if (args.includes("--help") || args.includes("-h"))
-        return { command, help: true, target, agents: null, roles, shell, keyStdin };
+    if (argv.includes("--help") || argv.includes("-h"))
+        return { command, help: true, target, agents: null, roles, shell, keyStdin, engineConfig };
     while (args.length > 0) {
         const arg = args.shift();
-        if (arg === "--no-shell")
+        if (command !== "init" && (arg === "--no-shell" || arg === "--key-stdin" ||
+            arg === "--agent" || arg.startsWith("--agent=") ||
+            arg === "--role" || arg.startsWith("--role="))) {
+            throw new RobisieError(`Opcja „${arg.split("=")[0]}” jest dostępna tylko dla polecenia init.`, "Zobacz `npx robisie help`.");
+        }
+        if (arg === "--engine-config" || arg.startsWith("--engine-config=")) {
+            const step = "Użyj `npx robisie doctor --engine-config <path>` z jedną niepustą ścieżką pliku.";
+            if (command !== "doctor")
+                throw new RobisieError("Opcja --engine-config jest dostępna tylko dla polecenia doctor.", step);
+            if (engineConfig !== null)
+                throw new RobisieError("Opcję --engine-config można podać tylko raz.", step);
+            const value = arg === "--engine-config" ? args.shift() ?? "" : arg.slice("--engine-config=".length);
+            if (!value.trim() || value.startsWith("-"))
+                throw new RobisieError("Opcja --engine-config wymaga ścieżki pliku.", step);
+            engineConfig = value;
+        }
+        else if (arg === "--no-shell")
             shell = false;
         else if (arg === "--key-stdin")
             keyStdin = true;
@@ -45,9 +67,9 @@ export function parseArgs(argv) {
                 throw new RobisieError("Opcja --role wymaga przypisania rola=dostawca.", ROLE_STEP);
             const [role, provider, extra] = value.split("=");
             if (!ROLE_IDS.some((id) => id === role))
-                throw new RobisieError(`Nieznana rola „${role || "(pusta rola --role)"}”.`, ROLE_STEP);
+                throw new RobisieError("Nieznana rola (--role).", ROLE_STEP);
             if (extra !== undefined || !provider || !isAgentId(provider))
-                throw new RobisieError(`Niepoprawny dostawca „${provider ?? ""}” dla roli „${role}” (--role ${value}).`, ROLE_STEP);
+                throw new RobisieError("Niepoprawny dostawca lub przypisanie (--role).", ROLE_STEP);
             const id = role;
             if (roles[id] && roles[id] !== provider)
                 throw new RobisieError(`Sprzeczne przypisania roli „${role}”: ${roles[id]} i ${provider}.`, ROLE_STEP);
@@ -58,11 +80,11 @@ export function parseArgs(argv) {
             const ids = value.split(",").map((v) => v.trim());
             // An empty value must not silently fall back to "every detected agent".
             if (ids.some((id) => id === "") || value.startsWith("--")) {
-                throw new RobisieError("Opcja --agent wymaga nazwy agenta.", `Podaj np. \`--agent codex\` (dostępne: ${AGENT_IDS.join(", ")}) albo pomiń --agent, żeby użyć wykrytych.`);
+                throw new RobisieError("Opcja --agent wymaga nazwy agenta.", ROLE_STEP);
             }
             for (const id of ids) {
                 if (!isAgentId(id))
-                    throw new RobisieError(`Nieznany agent „${id}”.`, `Użyj jednego z: ${AGENT_IDS.join(", ")}.`);
+                    throw new RobisieError("Nieznany agent (--agent).", ROLE_STEP);
                 if (!agents.includes(id))
                     agents.push(id);
             }
@@ -70,9 +92,9 @@ export function parseArgs(argv) {
         else if (command === "mcp" && target === null && !arg.startsWith("-"))
             target = arg;
         else
-            throw new RobisieError(`Nieznana opcja „${arg}”.`, "Zobacz `npx robisie help`.");
+            throw new RobisieError("Nieznana opcja argumentów CLI.", "Zobacz `npx robisie help`.");
     }
-    return { command, help: false, target, agents: agents.length > 0 ? agents : null, roles, shell, keyStdin };
+    return { command, help: false, target, agents: agents.length > 0 ? agents : null, roles, shell, keyStdin, engineConfig };
 }
 export async function run(argv, ctx) {
     try {
@@ -86,12 +108,30 @@ export async function run(argv, ctx) {
                 await init(ctx, { agents: args.agents, roles: args.roles, shell: args.shell, keyStdin: args.keyStdin });
                 return 0;
             case "doctor":
+                if (args.engineConfig !== null)
+                    return doctorEngineConfig(ctx, args.engineConfig);
+                if (ctx.env.ROBISIE_KEY) {
+                    try {
+                        const helper = await import(pathToFileURL(helperPath("client-launch-context")).href);
+                        if (!helper || typeof helper !== "object" || !("resolveProjectContext" in helper)
+                            || typeof helper.resolveProjectContext !== "function")
+                            throw new Error("Invalid project-context export");
+                        const result = helper.resolveProjectContext(ctx.env, ctx.cwd);
+                        if (!result || typeof result !== "object" || !("projectContext" in result)
+                            || typeof result.projectContext !== "string" || !("plannerAccess" in result)
+                            || result.plannerAccess !== "configured")
+                            throw new Error("Invalid project-context result");
+                    }
+                    catch {
+                        throw new RobisieError("Nie mogę potwierdzić kontekstu projektu używanego przez pomocnik klienta.", "W katalogu projektu wykonaj `unset ROBISIE_PROJECT_CONTEXT`, potem `npx robisie doctor`. Albo ustaw istniejący absolutny rzeczywisty katalog: `export ROBISIE_PROJECT_CONTEXT='/absolutna/sciezka/do/projektu'` (zastąp ścieżkę katalogiem projektu), potem `npx robisie doctor`.");
+                    }
+                }
                 return await doctor(ctx);
             case "uninstall":
                 return uninstall(ctx);
             case "mcp":
                 if (!args.target || !isHelperServer(args.target)) {
-                    throw new RobisieError(`Nieznany pomocnik „${args.target ?? ""}”.`, `Użyj jednego z: ${HELPER_SERVERS.join(", ")}.`);
+                    throw new RobisieError("Nieznany pomocnik (mcp).", `Użyj jednego z: ${HELPER_SERVERS.join(", ")}.`);
                 }
                 return await runHelper(args.target);
             case "--version":
@@ -104,13 +144,13 @@ export async function run(argv, ctx) {
                 ctx.out(HELP);
                 return 0;
             default:
-                throw new RobisieError(`Nieznane polecenie „${args.command}”.`, "Zobacz `npx robisie help`.");
+                throw new RobisieError("Nieznane polecenie CLI.", "Zobacz `npx robisie help`.");
         }
     }
     catch (error) {
         if (error instanceof RobisieError) {
             ctx.err(`✗ ${error.message}`);
-            ctx.err(`Następny krok: ${error.nextStep}`);
+            ctx.err(`Następny krok: ${recoveryStep(ctx, error.nextStep)}`);
         }
         else {
             ctx.err(`✗ Coś poszło nie tak: ${errorMessage(error)}`);

package/dist/commands.d.ts

@@ -0,0 +1,18 @@
+import { type AgentId } from "./agents.js";
+import { type Ctx } from "./context.js";
+import { type RoleProviders } from "./manifest.js";
+export interface InitOptions {
+    agents: AgentId[] | null;
+    roles?: Partial<RoleProviders>;
+    shell: boolean;
+    /** Read the key from piped stdin — only on request, so an open non-TTY stdin can never hang init. */
+    keyStdin: boolean;
+    rolesDir?: string;
+}
+/** Advice chooses an executable CLI, not merely a leftover configuration directory. */
+export declare function initRecoveryStep(ctx: Ctx, preferred?: AgentId): string;
+export declare function recoveryStep(ctx: Ctx, step: string): string;
+export declare function init(ctx: Ctx, options: InitOptions): Promise<void>;
+/** Returns the process exit code: 0 = all good, 1 = something needs one action. */
+export declare function doctor(ctx: Ctx): Promise<number>;
+export declare function uninstall(ctx: Ctx): number;