robisie 0.1.0 → 0.1.1

package/dist/commands.js

@@ -1,26 +1,60 @@
-import { readdirSync, rmdirSync, rmSync } from "node:fs";
-import { AGENT_LABELS, SHELL_EXPORT, agentPaths, agentOnPath, detectAgents, planAgent, removeCodexTables, shellProfile } from "./agents.js";
+import { lstatSync, readdirSync, rmdirSync, rmSync } from "node:fs";
+import { AGENT_IDS, AGENT_LABELS, SHELL_EXPORT, agentPaths, agentOnPath, detectAgents, planAgent, removeCodexTables, shellProfile } from "./agents.js";
 import { HELPER_SERVERS, KEY_ENV, KEY_PATTERN, PACKAGE_NAME, PACKAGE_VERSION } from "./constants.js";
 import { RobisieError, errorMessage } from "./context.js";
-import { applyOp, assertCodexChange, capture, entryPresent, prepareBlock, refusePrivateSymlink, restore, undoEntry } from "./fsops.js";
+import { applyOp, assertCodexChange, checkRecovery, preserveFileStep, capture, entryPresent, fingerprint, prepareBlock, refusePrivateSymlink, renderBlock, restore, undoEntry } from "./fsops.js";
 import { HELPER_TOOLS, probeHelper } from "./helpers.js";
 import { clientPaths, ensurePrivateDir, readKey, readManifest, writeKey, writeManifest, roleProviders, ROLE_IDS, ROLE_STEP } from "./manifest.js";
 import { assertCompatible, checkConnection, fetchContractVersion } from "./mcp.js";
 import { loadRoles, rolesDir } from "./roles.js";
 const NO_KEY_STEP = "Wygeneruj klucz worker na https://robisie.app/dashboard/connect; w zsh/bash wykonaj `unset ROBISIE_KEY`, potem lokalne `npx robisie init` i wklej klucz w ukrytym pytaniu (poza rozmową).";
+const KEY_FORMAT_STEP = `Skopiuj klucz jeszcze raz z https://robisie.app/dashboard/connect; uruchom lokalne \`npx robisie init\` i wklej klucz w ukrytym pytaniu (poza rozmową). Alternatywnie przekaż klucz przez stdin z jawną flagą: \`npx robisie init --key-stdin\` (poza rozmową i historią poleceń). Następnie wczytaj zapisany klucz do bieżącej sesji POSIX z tym samym XDG_CONFIG_HOME: \`${SHELL_EXPORT}\`, potem uruchom \`npx robisie doctor\`.`;
+const ENV_KEY_FORMAT_STEP = `W zsh/bash wykonaj \`unset ROBISIE_KEY\` — ENV ma pierwszeństwo przed pytaniem, stdin i plikiem. ${KEY_FORMAT_STEP}`;
+/** Advice chooses an executable CLI, not merely a leftover configuration directory. */
+export function initRecoveryStep(ctx, preferred) {
+    let prior;
+    try {
+        prior = readManifest(clientPaths(agentPaths(ctx).clientDir).manifest);
+    }
+    catch (error) {
+        return error instanceof RobisieError ? error.nextStep : `Nie mogę sprawdzić ewidencji instalacji: ${errorMessage(error)}. Sprawdź jej plik i uprawnienia przed ponowieniem init.`;
+    }
+    const missing = [...new Set(prior?.agents ?? [])].filter((id) => !agentOnPath(ctx, id));
+    const historyStep = missing.map((id) => `Zainstaluj program ${id} lub dodaj go do PATH.`).join(" ");
+    const provider = preferred && agentOnPath(ctx, preferred) ? preferred : AGENT_IDS.find((id) => agentOnPath(ctx, id));
+    if (!provider)
+        return `${historyStep || "Zainstaluj zewnętrznie Claude Code, Codex CLI albo OpenCode i dodaj program do PATH."} Potem ponów \`npx robisie doctor\`, aby przypisać role ceo, builder, quality.`;
+    return `${historyStep ? `${historyStep} Zachowana historia instalacji nadal wymaga tych programów. Potem: ` : ""}Uruchom \`npx robisie init --agent ${provider} --role ceo=${provider} --role builder=${provider} --role quality=${provider}\` (role: ceo, builder, quality; dostawcy: claude, codex, opencode).`;
+}
+export function recoveryStep(ctx, step) {
+    return step.includes(ROLE_STEP) ? step.replace(ROLE_STEP, initRecoveryStep(ctx)) : step;
+}
+function ceoProjectStep(count) {
+    return (count === 0
+        ? "Sprawdź gotowość projektu na https://robisie.app/dashboard/plugins/planer."
+        : "Uporządkuj widoczność projektów w discovery do 1; sam wybór projektu w panelu nie zmienia discovery.")
+        + " Potem uruchom `npx robisie doctor`.";
+}
 function entryId(entry) {
     return `${entry.kind}:${entry.path}:${entry.keyPath?.join(".") ?? ""}`;
 }
 async function obtainKey(ctx, keyStdin) {
     let key = ctx.env[KEY_ENV]?.trim() ?? "";
-    if (!key && ctx.askSecret)
+    let source = KEY_ENV;
+    if (!key && ctx.askSecret) {
+        source = "ukrytego pytania";
         key = (await ctx.askSecret("Wklej klucz robisie (rob_…, nie będzie widoczny): ")).trim();
-    if (!key && keyStdin && ctx.readStdin)
+    }
+    if (!key && keyStdin && ctx.readStdin) {
+        source = "stdin";
         key = (await ctx.readStdin()).trim().split(/\r?\n/)[0]?.trim() ?? "";
+    }
     if (!key)
-        throw new RobisieError("Brak klucza robisie.", NO_KEY_STEP);
+        throw new RobisieError("Brak klucza robisie.", ctx.askSecret === null && !keyStdin
+            ? `${NO_KEY_STEP} Brak terminala do ukrytego pytania; uruchom init w terminalu albo przekaż klucz przez stdin z jawną flagą --key-stdin (poza rozmową).`
+            : NO_KEY_STEP);
     if (!KEY_PATTERN.test(key))
-        throw new RobisieError("To nie wygląda na klucz robisie (oczekuję rob_ i 64 znaków 0-9a-f).", "Skopiuj klucz jeszcze raz z https://robisie.app/dashboard/connect i uruchom `npx robisie init`.");
+        throw new RobisieError(`Klucz z ${source} nie wygląda na klucz robisie (oczekuję rob_ i 64 znaków 0-9a-f).`, source === KEY_ENV ? ENV_KEY_FORMAT_STEP : KEY_FORMAT_STEP);
     return key;
 }
 export async function init(ctx, options) {
@@ -36,8 +70,9 @@ export async function init(ctx, options) {
         map = roleProviders({ agents: [], roleProviders: merged });
     }
     const selected = [...new Set([...Object.values(map ?? {}), ...detected])];
+    const mapChanged = prior !== null && ROLE_IDS.some((role) => previousMap?.[role] !== map?.[role]);
     if (selected.length === 0) {
-        throw new RobisieError("Nie znalazłem na tym komputerze Claude Code, Codex CLI ani OpenCode.", "Zainstaluj jednego z tych agentów albo wskaż go wprost, np. `npx robisie init --agent codex`.");
+        throw new RobisieError("Nie znalazłem na tym komputerze Claude Code, Codex CLI ani OpenCode.", initRecoveryStep(ctx));
     }
     const key = await obtainKey(ctx, options.keyStdin);
     // Refuse before writing anything: incompatible server, or a key that does not open the board.
@@ -53,14 +88,16 @@ export async function init(ctx, options) {
     const profile = options.shell ? shellProfile(ctx) : null;
     if (profile)
         planned.push({ owner: "shell", op: { kind: "block", path: profile, comment: "hash", body: SHELL_EXPORT } });
+    const priorById = new Map((prior?.entries ?? []).map((entry) => [entryId(entry), entry]));
     // Before writing anything, so a refusal leaves no half-done install behind.
     for (const { op } of planned) {
         refusePrivateSymlink(op);
+        const before = capture(op.path);
         if (op.kind === "block" && op.clean)
-            prepareBlock(capture(op.path).bytes?.toString("utf8") ?? null, op.comment, op.clean, op.body);
+            prepareBlock(before.bytes?.toString("utf8") ?? null, op.comment, op.clean, op.body);
+        checkRecovery(op, priorById.get(entryId(op)));
     }
     ensurePrivateDir(paths.dir);
-    const priorById = new Map((prior?.entries ?? []).map((entry) => [entryId(entry), entry]));
     const done = new Map(priorById);
     const agents = [...new Set([...(prior?.agents ?? []), ...selected])];
     let changed = 0;
@@ -99,14 +136,18 @@ export async function init(ctx, options) {
             changed += 1;
     }
     ctx.out(`robisie ${PACKAGE_VERSION}: połączono z tablicą (projektów: ${connection.projectCount}).`);
+    if (connection.projectCount !== 1)
+        ctx.out(`! CEO nie jest gotowy: wymaga dokładnie 1 projektu (projektów: ${connection.projectCount}). ${ceoProjectStep(connection.projectCount)}`);
     for (const id of selected)
         ctx.out(`✓ ${AGENT_LABELS[id]}: serwer MCP robisie i role klienta (CEO, Builder, Quality Officer) zainstalowane.`);
-    ctx.out(changed === 0 ? "Nic się nie zmieniło — wszystko było już zainstalowane." : `Zmienione pliki: ${changed} (kopie zapasowe: ${paths.backups}).`);
+    ctx.out(changed === 0 ? (mapChanged ? "✓ mapa ról zmieniona; konfiguracja agentów bez zmian." : "Nic się nie zmieniło — wszystko było już zainstalowane.") : `Zmienione pliki: ${changed} (kopie zapasowe: ${paths.backups}).`);
     if (profile)
         ctx.out(`✓ Klucz będzie dostępny jako ${KEY_ENV} w nowych terminalach (wpis w ${profile}).`);
-    else
-        ctx.out(`! Ustaw sam zmienną ${KEY_ENV} dla agenta, np.: ${SHELL_EXPORT}`);
-    ctx.out("Następny krok: otwórz nowy terminal i uruchom `npx robisie doctor`.");
+    else {
+        const reason = !options.shell ? "--no-shell" : !ctx.env.SHELL ? "brak SHELL" : "niewspierana powłoka/platforma";
+        ctx.out(`! Pominięto profil: ${reason}. Ustaw sam zmienną ${KEY_ENV} dla agenta, np.: ${SHELL_EXPORT}`);
+    }
+    ctx.out(`Następny krok: ${!map || map.ceo !== map.builder || map.ceo !== map.quality ? initRecoveryStep(ctx, map?.ceo) : "otwórz nowy terminal i uruchom `npx robisie doctor`."}`);
 }
 // ── doctor ───────────────────────────────────────────────────────────────────
 /** Returns the process exit code: 0 = all good, 1 = something needs one action. */
@@ -114,7 +155,7 @@ export async function doctor(ctx) {
     const problems = [];
     const fail = (line, nextStep) => {
         ctx.out(`✗ ${line}`);
-        problems.push(nextStep);
+        problems.push(recoveryStep(ctx, nextStep));
     };
     const guard = async (action) => {
         try {
@@ -129,6 +170,11 @@ export async function doctor(ctx) {
     };
     ctx.out(`Paczka ${PACKAGE_NAME} ${PACKAGE_VERSION}`);
     const paths = clientPaths(agentPaths(ctx).clientDir);
+    // Ledger recovery must remain the next step even when network checks fail.
+    let manifest = null;
+    await guard(async () => {
+        manifest = readManifest(paths.manifest);
+    });
     await guard(async () => {
         const version = await fetchContractVersion(ctx);
         assertCompatible(version);
@@ -136,26 +182,28 @@ export async function doctor(ctx) {
     });
     const envKey = ctx.env[KEY_ENV]?.trim() || null;
     let key = envKey;
+    let keyRead = false;
     await guard(async () => {
         key = envKey ?? readKey(paths.dir);
+        keyRead = true;
     });
     const usableKey = key;
-    if (!usableKey)
-        fail("Brak klucza robisie.", NO_KEY_STEP);
+    if (!usableKey) {
+        if (keyRead)
+            fail("Brak klucza robisie.", NO_KEY_STEP);
+    }
     else if (!KEY_PATTERN.test(usableKey))
-        fail("Zapisany klucz ma zły format.", "Uruchom `npx robisie init` i wklej klucz jeszcze raz.");
+        fail(`${envKey ? "Klucz z ROBISIE_KEY" : "Klucz w pliku"} ma zły format.`, envKey ? ENV_KEY_FORMAT_STEP : KEY_FORMAT_STEP);
     else {
         await guard(async () => {
             const connection = await checkConnection(ctx, usableKey);
             if (connection.contractVersion)
                 assertCompatible(connection.contractVersion);
             ctx.out(`✓ Połączenie działa: klucz otwiera tablicę (projektów: ${connection.projectCount}).`);
+            if (connection.projectCount !== 1)
+                fail(`CEO wymaga dokładnie 1 projektu (projektów: ${connection.projectCount}).`, ceoProjectStep(connection.projectCount));
         });
     }
-    let manifest = null;
-    await guard(async () => {
-        manifest = readManifest(paths.manifest);
-    });
     const installed = manifest;
     let map = null;
     if (installed)
@@ -164,19 +212,45 @@ export async function doctor(ctx) {
     for (const role of ROLE_IDS)
         ctx.out(`${role} → ${assignment?.[role] ?? "nie przypisano"}`);
     if (!installed || installed.agents.length === 0) {
-        fail("robisie nie jest zainstalowane dla żadnego agenta.", "Uruchom `npx robisie init`.");
+        fail("robisie nie jest zainstalowane dla żadnego agenta.", initRecoveryStep(ctx));
     }
     else {
+        for (const id of new Set(assignment ? Object.values(assignment) : installed.agents)) {
+            if (!agentOnPath(ctx, id)) {
+                const assigned = assignment ? ROLE_IDS.filter((role) => assignment[role] === id).join(", ") : "nie przypisano";
+                fail(`${assigned} → ${id}: ${detectAgents(ctx).includes(id) ? "katalog jest, programu nie ma w PATH" : "brak programu w PATH i katalogu dostawcy"}.`, `Zainstaluj program ${id} lub dodaj go do PATH i ponów \`npx robisie doctor\`.`);
+            }
+        }
         const byId = new Map(installed.entries.map((entry) => [entryId(entry), entry]));
         for (const id of new Set([...installed.agents, ...Object.values(assignment ?? {})])) {
-            const repair = `Uruchom \`npx robisie init --agent ${id}\` — uzupełni braki.`;
+            const repair = `Uruchom \`npx robisie init --agent ${id}\`${id === "claude" ? " z właściwym ROBISIE_KEY w środowisku" : ""} — uzupełni braki.`;
             await guard(async () => {
                 // A complete install = every change init plans for this agent is recorded AND still in place.
                 const expected = planAgent(ctx, id, loadRoles(), usableKey ?? `rob_${"0".repeat(64)}`);
                 const missing = expected.filter((op) => {
                     const entry = byId.get(entryId(op));
+                    try {
+                        checkRecovery(op, entry);
+                    }
+                    catch (error) {
+                        if (!(error instanceof RobisieError))
+                            throw error;
+                        const detail = assignment ? ROLE_IDS.filter((role) => assignment[role] === id).map((role) => `${role} → ${id}: niepełna instalacja`).join(", ") : "";
+                        throw new RobisieError(`${AGENT_LABELS[id]}: ${error.message}${detail ? ` Role: ${detail}.` : ""}`, error.nextStep);
+                    }
                     if (!entry || entry.owner !== id || !entryPresent(entry))
                         return true;
+                    if (op.kind === "file" && capture(op.path).bytes?.toString("utf8") !== op.content)
+                        return true;
+                    if (op.kind === "block" && op.comment === "html") {
+                        const current = (capture(op.path).bytes?.toString("utf8") ?? "").replace(/\r\n/g, "\n").split("\n");
+                        const planned = renderBlock(op.comment, op.body).trimEnd().split("\n");
+                        const start = current.indexOf(planned[0] ?? "");
+                        if (start < 0 || current.slice(start, start + planned.length).join("\n") !== planned.join("\n"))
+                            return true;
+                    }
+                    if (id === "claude" && op.kind === "json" && (entry.kind !== "json" || fingerprint(op.value) !== entry.fingerprint))
+                        return true;
                     if (op.kind === "block" && op.clean) {
                         try {
                             const current = capture(op.path).bytes?.toString("utf8") ?? "";
@@ -201,16 +275,13 @@ export async function doctor(ctx) {
                 }
             });
         }
-        for (const id of new Set(assignment ? Object.values(assignment) : installed.agents)) {
-            if (!agentOnPath(ctx, id)) {
-                const assigned = assignment ? ROLE_IDS.filter((role) => assignment[role] === id).join(", ") : "nie przypisano";
-                fail(`${assigned} → ${id}: ${detectAgents(ctx).includes(id) ? "katalog jest, programu nie ma w PATH" : "brak programu w PATH i katalogu dostawcy"}.`, `Zainstaluj program ${id} lub dodaj go do PATH i ponów \`npx robisie doctor\`.`);
-            }
+        if (!assignment) {
+            const provider = installed.agents[0];
+            fail("Role: nie przypisano dostawców.", `Uruchom \`npx robisie init --agent ${provider} --role ceo=${provider} --role builder=${provider} --role quality=${provider}\`. Aby wybrać innego zainstalowanego dostawcę (${installed.agents.join(", ")}), zastąp ${provider} jego nazwą we wszystkich czterech miejscach.`);
         }
-        if (!assignment)
-            fail("Role: nie przypisano dostawców.", `Uruchom npx robisie init z pełną mapą. ${ROLE_STEP}`);
         else if (assignment.builder !== assignment.ceo || assignment.quality !== assignment.ceo) {
-            fail(`Mieszana mapa: Quality Officer jako podagent u dostawcy CEO (${assignment.ceo}); polecenie Buildera w formacie dostawcy CEO (${assignment.ceo}). Wykonanie mieszanych ról to następny zakres.`, "Wybierz jednego dostawcę dla trzech ról przez `npx robisie init --role ceo=claude --role builder=claude --role quality=claude` albo zachowaj mapę i poczekaj na obsługę mieszanych ról.");
+            const provider = assignment.ceo;
+            fail(`Mieszana mapa: Quality Officer jako podagent u dostawcy CEO (${assignment.ceo}); polecenie Buildera w formacie dostawcy CEO (${assignment.ceo}). Wykonanie mieszanych ról to następny zakres.`, `Wybierz jednego dostawcę dla trzech ról przez \`npx robisie init --agent ${provider} --role ceo=${provider} --role builder=${provider} --role quality=${provider}\`. Aby wybrać innego zainstalowanego dostawcę (${installed.agents.join(", ")}), zastąp ${provider} jego nazwą we wszystkich czterech miejscach albo zachowaj mapę i poczekaj na obsługę mieszanych ról.`);
         }
         for (const name of HELPER_SERVERS) {
             await guard(async () => {
@@ -219,11 +290,11 @@ export async function doctor(ctx) {
                     tools = await probeHelper(name, ctx.env, ctx.cwd);
                 }
                 catch (error) {
-                    throw new RobisieError(`Pomocnik ${name} nie działa na tym komputerze: ${errorMessage(error)}`, "Sprawdź Node.js (wymagany 20+). Przeinstaluj otrzymany plik .tgz w katalogu instalacji: `npm i ./robisie-0.1.0.tgz` (użyj nazwy otrzymanego pliku), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+                    throw new RobisieError(`Pomocnik ${name} nie działa na tym komputerze: ${errorMessage(error)}`, "Sprawdź Node.js (wymagany 20+). Przeinstaluj paczkę z npm w katalogu instalacji: `npm i robisie@latest`, potem lokalne `npx robisie init` i `npx robisie doctor`.");
                 }
                 const absent = HELPER_TOOLS[name].filter((tool) => !tools.includes(tool));
                 if (absent.length > 0)
-                    throw new RobisieError(`Pomocnik ${name} nie ma narzędzi: ${absent.join(", ")}.`, "Przeinstaluj otrzymany plik .tgz w katalogu instalacji: `npm i ./robisie-0.1.0.tgz` (użyj nazwy otrzymanego pliku), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+                    throw new RobisieError(`Pomocnik ${name} nie ma narzędzi: ${absent.join(", ")}.`, "Przeinstaluj paczkę z npm w katalogu instalacji: `npm i robisie@latest`, potem lokalne `npx robisie init` i `npx robisie doctor`.");
                 ctx.out(`✓ Pomocnik ${name} działa (${tools.length} narzędzi).`);
             });
         }
@@ -250,69 +321,103 @@ function removeEmptyDir(path) {
             return true;
         if (code === "ENOTEMPTY" || code === "EEXIST")
             return false;
-        throw new RobisieError(`Nie mogę usunąć katalogu ${path}: ${errorMessage(error)}`, `Usuń katalog ${path} ręcznie.`);
+        throw new RobisieError(`Nie mogę usunąć katalogu ${path}: ${errorMessage(error)}`, `Sprawdź uprawnienia i usuń przeszkodę uniemożliwiającą opróżnienie katalogu ${path}, zachowując ewidencję instalacji i kopie użytkownika. Potem ponów \`npx robisie uninstall\`.`);
     }
 }
 export function uninstall(ctx) {
     const agent = agentPaths(ctx);
     const paths = clientPaths(agent.clientDir);
-    const manifest = readManifest(paths.manifest);
-    let hasBackups = false;
     try {
-        hasBackups = readdirSync(paths.backups).length > 0;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT") {
-            throw new RobisieError(`Nie mogę sprawdzić kopii zapasowych: ${errorMessage(error)}`, `Sprawdź uprawnienia do ${paths.backups} i ponów polecenie.`);
+        const manifest = readManifest(paths.manifest);
+        let hasBackups = false;
+        try {
+            hasBackups = readdirSync(paths.backups).length > 0;
         }
-    }
-    const backupNotice = hasBackups ? `Kopie zapasowe pozostają w ${paths.backups}.` : "";
-    if (!manifest) {
-        ctx.out("Nie znaleziono zapisu instalacji — nic nie zmieniono (0 zmian).");
-        ctx.out(`Jeśli wpis robisie pozostał, usuń go ręcznie z konfiguracji swojego agenta: ${agent.claudeJson}, ${agent.codexConfig} lub ${agent.opencodeJson} (albo ${agent.opencodeJsonc}).`);
-        if (backupNotice)
-            ctx.out(backupNotice);
-        return 0;
-    }
-    const pending = new Set(manifest.entries);
-    // The manifest records the installed location; CODEX_HOME may have changed since init.
-    const codexConfigs = new Set(manifest.entries.filter((entry) => entry.kind === "block" && entry.comment === "hash" && (entry.owner === "codex" || entry.path === agent.codexConfig)).map((entry) => entry.path));
-    const evidence = `${backupNotice ? `${backupNotice} ` : ""}Pozostałe zmiany: ${paths.manifest}.`;
-    try {
-        // Refuse unsafe Codex edits before deleting the key, undoing roles or recording progress.
-        for (const entry of manifest.entries) {
-            if (entry.kind === "block" && codexConfigs.has(entry.path)) {
-                prepareBlock(capture(entry.path).bytes?.toString("utf8") ?? null, entry.comment, (text) => removeCodexTables(text, true));
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw new RobisieError(`Nie mogę sprawdzić kopii zapasowych: ${errorMessage(error)}`, `Sprawdź uprawnienia do ${paths.backups} i ponów polecenie.`);
             }
         }
-        // The key is not needed to finish an uninstall, even after a warning or a failure.
-        rmSync(paths.key, { force: true });
-        for (const entry of [...manifest.entries].reverse()) {
-            const warning = undoEntry(entry, codexConfigs.has(entry.path) ? (text) => removeCodexTables(text, true) : undefined);
-            if (warning)
-                ctx.out(`! ${warning} ${evidence}`);
-            else {
-                pending.delete(entry);
-                // A later init must not mistake an already restored user role for an edited installed one.
-                writeManifest(paths.dir, { agents: manifest.agents, roleProviders: manifest.roleProviders, entries: [...pending] });
+        const backupNotice = hasBackups ? `Kopie zapasowe pozostają w ${paths.backups}.` : "";
+        if (!manifest) {
+            ctx.out("Nie znaleziono zapisu instalacji — nic nie zmieniono (0 zmian).");
+            ctx.out(`Jeśli wpis robisie pozostał, usuń go ręcznie z konfiguracji swojego agenta: ${agent.claudeJson}, ${agent.codexConfig} lub ${agent.opencodeJson} (albo ${agent.opencodeJsonc}).`);
+            if (backupNotice)
+                ctx.out(backupNotice);
+            return 0;
+        }
+        const pending = new Set(manifest.entries);
+        // The manifest records the installed location; CODEX_HOME may have changed since init.
+        const codexConfigs = new Set(manifest.entries.filter((entry) => entry.kind === "block" && entry.comment === "hash" && (entry.owner === "codex" || entry.path === agent.codexConfig)).map((entry) => entry.path));
+        const evidence = `${backupNotice ? `${backupNotice} ` : ""}Pozostałe zmiany: ${paths.manifest}.`;
+        const leftovers = [];
+        try {
+            // Refuse missing role originals and unsafe Codex edits before any uninstall mutation.
+            for (const entry of manifest.entries) {
+                if (entry.kind === "file" && entry.backup && capture(entry.backup).bytes === null) {
+                    throw new RobisieError(`Brak kopii oryginału ${entry.backup} dla ${entry.path}.`, `Przywróć tę kopię z własnego archiwum do ${entry.backup}; bez niej zatrzymaj się, nie usuwaj pliku ${entry.path} i nie ponawiaj uninstall. Po przywróceniu kopii ponów \`npx robisie uninstall\`.`);
+                }
+                if (entry.kind === "block" && codexConfigs.has(entry.path)) {
+                    prepareBlock(capture(entry.path).bytes?.toString("utf8") ?? null, entry.comment, (text) => removeCodexTables(text, true));
+                }
+            }
+            // The key is not needed to finish an uninstall, even after a warning or a failure.
+            rmSync(paths.key, { force: true });
+            for (const entry of [...manifest.entries].reverse()) {
+                const warning = undoEntry(entry, codexConfigs.has(entry.path) ? (text) => removeCodexTables(text, true) : undefined);
+                if (warning)
+                    ctx.out(`! ${warning} ${evidence}`);
+                else {
+                    pending.delete(entry);
+                    // A later init must not mistake an already restored user role for an edited installed one.
+                    writeManifest(paths.dir, { agents: manifest.agents, roleProviders: manifest.roleProviders, entries: [...pending] });
+                }
+            }
+            if (pending.size > 0) {
+                ctx.out(`! Nie udało się cofnąć wszystkich zmian. ${evidence}`);
+                const next = [...pending].map((entry) => `${preserveFileStep(entry.path)}${entry.backup ? ` Przywróć oryginał z kopii ${entry.backup} do ${entry.path}, zachowując tę kopię.` : ""}`).join(" ");
+                ctx.out(`Następny krok: ${next} Potem ponów \`npx robisie uninstall\`.`);
+                return 1;
+            }
+            for (const dir of [paths.codexRoles, paths.roles])
+                if (!removeEmptyDir(dir))
+                    leftovers.push(dir);
+            // The ledger lives inside paths.dir, so only the final rmdir requires removing it first.
+            try {
+                rmSync(paths.manifest, { force: true });
+                if (!removeEmptyDir(paths.dir))
+                    leftovers.push(paths.dir);
+            }
+            catch (error) {
+                try {
+                    writeManifest(paths.dir, { agents: manifest.agents, roleProviders: manifest.roleProviders, entries: [...pending] });
+                }
+                catch (restoreError) {
+                    throw new RobisieError(`${errorMessage(error)} Nie udało się odtworzyć ewidencji ${paths.manifest}: ${errorMessage(restoreError)}`, `Zachowaj katalog ${paths.dir} i kopie użytkownika. ${restoreError instanceof RobisieError ? restoreError.nextStep : "Sprawdź uprawnienia do katalogu ewidencji."} Nie ponawiaj \`npx robisie uninstall\` bez poprawnej ewidencji instalacji.`);
+                }
+                throw error;
             }
         }
-        if (pending.size > 0) {
-            ctx.out(`! Nie udało się cofnąć wszystkich zmian. ${evidence}`);
-            ctx.out("Następny krok: porównaj pozostawione pliki z kopiami, zachowaj swoje zmiany i ponów `npx robisie uninstall`.");
-            return 1;
+        catch (error) {
+            throw new RobisieError(`Nie udało się dokończyć odinstalowania: ${errorMessage(error)}`, `${error instanceof RobisieError ? error.nextStep : "Rozwiąż problem i ponów `npx robisie uninstall`."} ${evidence}`);
         }
-        rmSync(paths.manifest, { force: true });
+        ctx.out(`✓ Usunięto wpisy i bloki robisie oraz cofnięto instalację ról (${manifest.entries.length} zmian).`);
+        if (backupNotice)
+            ctx.out(backupNotice);
+        if (leftovers.length > 0)
+            ctx.out(`Zostawiłem niepuste katalogi: ${leftovers.join(", ")}.`);
+        ctx.out("Następny krok: otwórz nowy terminal, żeby zmienna ROBISIE_KEY zniknęła z sesji.");
+        return 0;
     }
-    catch (error) {
-        throw new RobisieError(`Nie udało się dokończyć odinstalowania: ${errorMessage(error)}`, `${error instanceof RobisieError ? error.nextStep : "Rozwiąż problem i ponów `npx robisie uninstall`."} ${evidence}`);
+    finally {
+        let state = "pozostaje";
+        try {
+            lstatSync(paths.key);
+        }
+        catch (error) {
+            const code = error.code;
+            state = code === "ENOENT" ? "nie istnieje" : `nie można ustalić (${typeof code === "string" && /^E[A-Z0-9_]{1,39}$/.test(code) ? code : "błąd metadanych"})`;
+        }
+        ctx.out(`Lokalny plik klucza: ${state} — ${paths.key}.`);
     }
-    const leftovers = [paths.codexRoles, paths.roles, paths.dir].filter((dir) => !removeEmptyDir(dir));
-    ctx.out(`✓ Usunięto wpisy i bloki robisie oraz cofnięto instalację ról (${manifest.entries.length} zmian).`);
-    if (backupNotice)
-        ctx.out(backupNotice);
-    if (leftovers.length > 0)
-        ctx.out(`Zostawiłem niepuste katalogi: ${leftovers.join(", ")}.`);
-    ctx.out("Następny krok: otwórz nowy terminal, żeby zmienna ROBISIE_KEY zniknęła z sesji.");
-    return 0;
 }

package/dist/constants.d.ts

@@ -0,0 +1,32 @@
+/** Package identity and the server contract it speaks. */
+export declare const PACKAGE_NAME = "robisie";
+export declare const PACKAGE_VERSION = "0.1.1";
+/**
+ * MAJOR of the agent-API contract this package understands.
+ * PARITY: src/lib/mcp/contract-version.ts (AGENT_API_CONTRACT_VERSION) on the server.
+ */
+export declare const SUPPORTED_CONTRACT_MAJOR = 1;
+export declare const DEFAULT_ORIGIN = "https://robisie.app";
+export declare const MCP_SERVER_NAME = "robisie";
+export declare const KEY_ENV = "ROBISIE_KEY";
+/**
+ * Local stdio helpers the client roles call (`mcp__client-launch-context__…`, `mcp__ceo-client-launcher__…`).
+ * Shipped in `helpers/` (verbatim copies of the repo's scripts/) and started as `npx -y robisie@<version> mcp <name>`.
+ */
+export declare const HELPER_SERVERS: readonly ["client-launch-context", "ceo-client-launcher"];
+export type HelperServer = (typeof HELPER_SERVERS)[number];
+/** Environment the helpers read: credential, Builder card, project and installed configuration. */
+export declare const HELPER_ENV: readonly ["ROBISIE_KEY", "ROBISIE_CARD_REF", "ROBISIE_PROJECT_CONTEXT", "XDG_CONFIG_HOME", "CODEX_HOME"];
+export declare function helperCommand(name: HelperServer): {
+    command: string;
+    args: string[];
+};
+export declare const KEY_PATTERN: RegExp;
+export declare const CONTRACT_VERSION_HEADER = "x-robisie-contract-version";
+/** Text markers delimiting what `init` wrote. `uninstall` removes only what sits between them. */
+export declare const MARK_BEGIN = ">>> robisie (zarz\u0105dzane przez `npx robisie`, nie edytuj) >>>";
+export declare const MARK_END = "<<< robisie <<<";
+/** First-line marker of every role file `init` owns. */
+export declare const FILE_MARK = "robisie:managed";
+export declare function mcpUrl(origin: string): string;
+export declare function wellKnownUrl(origin: string): string;

package/dist/constants.js

@@ -1,6 +1,6 @@
 /** Package identity and the server contract it speaks. */
 export const PACKAGE_NAME = "robisie";
-export const PACKAGE_VERSION = "0.1.0"; // x-release-please-version
+export const PACKAGE_VERSION = "0.1.1"; // x-release-please-version
 /**
  * MAJOR of the agent-API contract this package understands.
  * PARITY: src/lib/mcp/contract-version.ts (AGENT_API_CONTRACT_VERSION) on the server.
@@ -14,8 +14,8 @@ export const KEY_ENV = "ROBISIE_KEY";
  * Shipped in `helpers/` (verbatim copies of the repo's scripts/) and started as `npx -y robisie@<version> mcp <name>`.
  */
 export const HELPER_SERVERS = ["client-launch-context", "ceo-client-launcher"];
-/** Environment the helpers read: credential, the Builder's card and the selected project directory. */
-export const HELPER_ENV = [KEY_ENV, "ROBISIE_CARD_REF", "ROBISIE_PROJECT_CONTEXT"];
+/** Environment the helpers read: credential, Builder card, project and installed configuration. */
+export const HELPER_ENV = [KEY_ENV, "ROBISIE_CARD_REF", "ROBISIE_PROJECT_CONTEXT", "XDG_CONFIG_HOME", "CODEX_HOME"];
 export function helperCommand(name) {
     return { command: "npx", args: ["-y", `${PACKAGE_NAME}@${PACKAGE_VERSION}`, "mcp", name] };
 }

package/dist/context.d.ts

@@ -0,0 +1,24 @@
+/** Everything a command touches outside its own logic — injectable, so tests run on a temp HOME. */
+export interface Ctx {
+    home: string;
+    cwd: string;
+    env: Readonly<Record<string, string | undefined>>;
+    platform: NodeJS.Platform;
+    fetch: typeof fetch;
+    out: (line: string) => void;
+    err: (line: string) => void;
+    /** Interactive hidden prompt; null when there is no terminal to ask on. */
+    askSecret: ((question: string) => Promise<string>) | null;
+    /** Whole stdin when it is piped (not a terminal); null otherwise. */
+    readStdin: (() => Promise<string>) | null;
+    origin: string;
+}
+/** A failure the client can act on: what happened + exactly one next step (both in Polish). */
+export declare class RobisieError extends Error {
+    readonly nextStep: string;
+    constructor(message: string, nextStep: string);
+}
+export declare function errorMessage(error: unknown): string;
+/** One POSIX shell word: single-quoted, each `'` written as `'\''` (paths like `/Users/O'Connor`). */
+export declare function shellQuote(value: string): string;
+export declare function nodeCtx(): Ctx;

package/dist/context.js

@@ -29,15 +29,31 @@ function hiddenPrompt(question) {
     });
     const rl = createInterface({ input: process.stdin, output, terminal: true });
     return new Promise((resolve, reject) => {
-        rl.on("SIGINT", () => {
-            rl.close();
-            reject(new RobisieError("Przerwano.", "Uruchom ponownie `npx robisie init`."));
-        });
-        rl.question(question, (answer) => {
-            rl.close();
+        let settled = false;
+        let inputFailed = false;
+        const accept = (answer) => {
             process.stdout.write("\n");
             resolve(answer);
+        };
+        const finish = (answer) => {
+            if (settled)
+                return;
+            settled = true;
+            rl.close();
+            if (answer !== undefined && !inputFailed)
+                return accept(answer);
+            reject(new RobisieError("Przerwano.", "Uruchom ponownie `npx robisie init`."));
+        };
+        const cancel = () => finish();
+        rl.on("SIGINT", cancel);
+        rl.on("close", cancel);
+        rl.on("error", () => {
+            // setRawMode can emit EIO synchronously while close is cleaning up a lost PTY.
+            inputFailed = true;
+            // Let that close finish before cancellation attempts another cleanup.
+            queueMicrotask(cancel);
         });
+        rl.question(question, finish);
         muted = true;
     });
 }

package/dist/dependency-readiness.d.ts

@@ -0,0 +1,13 @@
+export type CardLike = {
+    seedBriefDigest?: string | null;
+    detailsReadError?: string | null;
+    id: string;
+    status?: string | null;
+    details?: Record<string, unknown> | null;
+    dependsOn?: string[];
+};
+export declare const HOLD_DETAILS_KEYS: readonly ["reksio_withheld", "hold", "seed_obligation", "seed_brief"];
+export declare const FACTORY_DEPENDENCY_KEYS: readonly ["landed", "test", "review", "maszynista", "reksio_withheld", "hold", "seed_obligation"];
+export declare function factoryDependenciesReady(card: CardLike & {
+    depsReady?: boolean;
+}, predecessors?: ReadonlyMap<string, CardLike>): boolean;

package/dist/dependency-readiness.js

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+export const HOLD_DETAILS_KEYS = ["reksio_withheld", "hold", "seed_obligation", "seed_brief"];
+export const FACTORY_DEPENDENCY_KEYS = ["landed", "test", "review", "maszynista", "reksio_withheld", "hold", "seed_obligation"];
+function briefSha(details, digest) {
+    if (digest !== undefined)
+        return digest;
+    const brief = details?.seed_brief;
+    return nonempty(brief) ? createHash("sha256").update(brief).digest("hex") : null;
+}
+function holdActive(details, digest) {
+    const hold = details?.hold;
+    if (hold === undefined || hold === null)
+        return false;
+    if (!record(hold) || hold.release !== "packet_changed")
+        return true;
+    // Zlecenie zasiewu bez potwierdzonego odbioru (pending) trzyma hold niezależnie od briefu: częściowo osadzony albo niezgodny
+    // pakiet nie wychodzi do promocji, dopóki most nie zamknie zlecenia po udanym read-backu.
+    const obligation = details?.seed_obligation;
+    if (record(obligation) && obligation.status === "pending")
+        return true;
+    const sha = hold.seed_brief_sha256;
+    if (sha != null && (typeof sha !== "string" || !/^[0-9a-f]{64}$/.test(sha)))
+        return true;
+    return (hold.seed_brief_sha256 ?? null) === briefSha(details, digest);
+}
+function draftHeld(details, digest) {
+    return details?.reksio_withheld === true || holdActive(details, digest);
+}
+export function factoryDependenciesReady(card, predecessors) {
+    if (card.detailsReadError)
+        return false;
+    if (predecessors === undefined || card.dependsOn === undefined)
+        return card.depsReady === true; // legacy callers
+    if (!Array.isArray(card.dependsOn))
+        return false;
+    return card.dependsOn.every(id => {
+        const dep = predecessors?.get(id);
+        if (!dep || dep.id !== id || dep.detailsReadError)
+            return false;
+        if (dep.status === "done")
+            return true;
+        if (dep.status !== "delivered")
+            return false;
+        const d = dep.details ?? {};
+        const land = asRecord(d.landed), test = asRecord(d.test);
+        const at = Date.parse(String(test.at)), landedAt = Date.parse(String(land.at));
+        if (!landedSha(dep) || test.sha !== land.sha || !["PASS", "PASS_NEEDS_VALIDATOR"].includes(String(test.verdict))
+            || !timestamp(test.at) || !timestamp(land.at) || at < landedAt
+            || at > Date.now() || draftHeld(d, dep.seedBriefDigest)
+            || (d.review != null && !record(d.review)) || (d.maszynista != null && !record(d.maszynista)))
+            return false;
+        const machine = asRecord(d.maszynista), review = asRecord(d.review);
+        // Old failed attempts survive delivery; only a later (or undated) conflict blocks it.
+        const newer = (value) => !Number.isFinite(Date.parse(String(value))) || Date.parse(String(value)) >= landedAt;
+        if (["worker", "review", "landing", "repair", "blocked"].includes(String(machine.phase)) && newer(machine.at))
+            return false;
+        if (review.verdict === "FAIL" && newer(review.at))
+            return false;
+        return true;
+    });
+}
+function validTestSha(value) {
+    return typeof value === "string" && /^[a-f0-9]{7,40}$/i.test(value);
+}
+function landedSha(card) {
+    const landed = card.details?.landed;
+    return record(landed) && validTestSha(landed.sha) ? landed.sha : null;
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+    return record(value) ? value : {};
+}
+function nonempty(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function timestamp(value) {
+    return nonempty(value) && Number.isFinite(Date.parse(value));
+}