robisie 0.1.0 → 0.1.1

package/dist/intent-rules/done-when-roles.d.ts

@@ -0,0 +1,21 @@
+export interface NonWorkerItem {
+    index: number;
+    role: string;
+    excerpt: string;
+}
+/** Regex roli jako słowa z dosłownych form (wielkość liter ma znaczenie: „CR” nie łapie „cr-blocker.ts”). Dłuższe formy najpierw. */
+export declare function roleMatcher(forms: readonly string[]): RegExp;
+export type NonWorkerDoneWhen = (doneWhen: unknown) => NonWorkerItem[];
+/** Reguła dla ról instancji: pozycje done_when wymagające cudzej czynności lub dowodu live. Nie-stringi pomija. */
+export declare function nonWorkerDoneWhenFor(forms: readonly string[]): NonWorkerDoneWhen;
+export interface NonWorkerRefusal {
+    reason: string;
+    index: number;
+    role: string;
+    excerpt: string;
+    doneWhenSha: string;
+}
+/** Odmowa dla done_when wymagającego cudzej czynności lub dowodu live; null = brak zastrzeżeń. */
+export declare function nonWorkerRefusal(rule: NonWorkerDoneWhen, doneWhen: unknown): NonWorkerRefusal | null;
+/** Sam powód odmowy (string) — jak `nonWorkerDoneWhenReason` w oryginale. */
+export declare function nonWorkerDoneWhenReason(rule: NonWorkerDoneWhen, doneWhen: unknown): string | null;

package/dist/intent-rules/done-when-roles.js

@@ -0,0 +1,101 @@
+// done_when karty = WYŁĄCZNIE to, co Worker spełnia sam w repo (test / diff / polecenie). Odbiór, dedup, admission, review/CI/land
+// i realne użycie to sprawy koordynatora i pipeline (pola independent_receiver / intended_real_use), nigdy done_when:
+// siewca przepisuje done_when do briefu jako warunek startu, a Worker bez kanału dostawy staje.
+//
+// Port maszynista/done-when-roles.ts z robisie-app (kopia: docs/zrodla/kompilator/done-when-roles.ts). Jedyna zmiana:
+// zamknięta lista ról z oryginału (ROLE) jest budowana z form ról instancji w robisie.config.json (roles.*.forms).
+// Reszta — luka słów, czasowniki, strona bierna, szyk przestawny, dowód live — bez zmian.
+//
+// Sprawdzian jest SKŁADNIOWY, nie słowny: samo wspomnienie roli („odpowiedź CR na B”, `recipientRole: "control-room"`)
+// to legalne kryterium Workera; zatrzymujemy dopiero pozycję, w której rola WYKONUJE czynność (CR odbiera / potwierdza / porównuje /
+// dostarcza ..., „odebrane przez CR”, „odbiera CR”). Heurystyka: zwykły język polski, więc rozpoznaje zamkniętą listę czasowników;
+// reszta to znane fałszywe negatywy (otwarte ryzyko).
+import { createHash } from 'node:crypto';
+const WORD_START = String.raw `(?<![\p{L}\p{M}\p{N}_])`;
+const WORD_END = String.raw `(?![\p{L}\p{M}\p{N}_])`;
+/** Słowo luki między rolą a czynnością; „Worker” przerywa lukę (zmiana podmiotu). Interpunkcja kończy zdanie/człon, więc luka jej nie obejmuje. */
+const GAP_WORD = String.raw `\s+(?!worker)[\p{L}\p{N}_/-]+`;
+const MAX_GAP = 5;
+/** Czasowniki czynności roli (os. 3. czas teraźniejszy/przyszły/przeszły + bezokolicznik). Tylko formy osobowe i bezokolicznik: „potwierdzony odbiór” to nie czynność. */
+const ACTION_VERBS = [
+    'odbiera(?:ją)?|odbierze|odbiorą|odebra(?:ł|ła|li)|odbierać|odebrać',
+    'porównuje|porównują|porówna|porównają|porównał|porównała|porównali|porównać',
+    'dostarcza|dostarczają|dostarczy|dostarczą|dostarczył|dostarczyła|dostarczyli|dostarczyć',
+    'potwierdza|potwierdzają|potwierdzi|potwierdzą|potwierdził|potwierdziła|potwierdzili|potwierdzić',
+    'odczytuje|odczytują|odczyta|odczytają|odczytał|odczytała|odczytali|odczytać',
+    'zatwierdza|zatwierdzają|zatwierdzi|zatwierdzą|zatwierdził|zatwierdziła|zatwierdzili|zatwierdzić',
+    'akceptuje|akceptują|zaakceptuje|zaakceptują|zaakceptował|zaakceptowała|zaakceptowali|zaakceptować',
+    'weryfikuje|weryfikują|zweryfikuje|zweryfikują|zweryfikował|zweryfikowała|zweryfikowali|zweryfikować',
+    'waliduje|walidują|zwaliduje|zwalidują|zwalidował|zwalidowała|zwalidować',
+    'ocenia|oceniają|oceni|ocenią|ocenił|oceniła|ocenili|ocenić',
+    'sprawdza|sprawdzają|sprawdzi|sprawdzą|sprawdził|sprawdziła|sprawdzili|sprawdzić',
+    'decyduje|decydują|zdecyduje|zdecydują|zdecydował|zdecydowała|zdecydowali|zdecydować',
+    'rozstrzyga|rozstrzygają|rozstrzygnie|rozstrzygną|rozstrzygnął|rozstrzygnęła|rozstrzygnąć',
+    'rozlicza|rozliczają|rozliczy|rozliczą|rozliczył|rozliczyła|rozliczyli|rozliczyć',
+    'uzgadnia|uzgadniają|uzgodni|uzgodnią|uzgodnił|uzgodniła|uzgodnili|uzgodnić',
+    'wydaje|wydają|wyda|wydadzą|wydał|wydała|wydali|wydać',
+    'ratyfikuje|ratyfikują|ratyfikował|ratyfikowała|ratyfikować',
+    'otrzymuje|otrzymują|otrzyma|otrzymają|otrzymał|otrzymała|otrzymali|otrzymać',
+    'migruje|migrują|zmigruje|zmigrują',
+    'wykona|wykonają|wykonuje|wykonują|wykonał|wykonała|wykonali|wykonać',
+].join('|');
+/** Strona bierna z wykonawcą: „odebrane (osobno) przez CR”, „dostarczonej przez CR”, „odbiór przez Control Room”. */
+const PASSIVE_STEMS = String.raw `(?:odebran|odbiór|odbior|zatwierdzon|potwierdzon|zweryfikowan|zaakceptowan|rozliczon|dostarczon|sprawdzon|ocenion|wykonan|odczytan|porównan|zwalidowan|uzgodnion)\p{L}*`;
+/** Rola jest podmiotem: „CR (po aktywacji hosta) odbiera …”. Dopasowanie od końca roli. */
+const ACTION_AFTER_ROLE = new RegExp(`^(?:${GAP_WORD}){0,${MAX_GAP}}?\\s+(?:${ACTION_VERBS})${WORD_END}`, 'iu');
+/** Rola jest wykonawcą w stronie biernej. Dopasowanie do początku roli. */
+const PASSIVE_BEFORE_ROLE = new RegExp(`${WORD_START}${PASSIVE_STEMS}(?:${GAP_WORD}){0,2}?\\s+przez\\s+$`, 'iu');
+/** Szyk przestawny: „Zgodę wydaje właściciel”, „… odbiera CR”. Dopasowanie do początku roli. */
+const ACTION_BEFORE_ROLE = new RegExp(`${WORD_START}(?:${ACTION_VERBS})${WORD_END}(?:${GAP_WORD}){0,1}?\\s+$`, 'iu');
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Regex roli jako słowa z dosłownych form (wielkość liter ma znaczenie: „CR” nie łapie „cr-blocker.ts”). Dłuższe formy najpierw. */
+export function roleMatcher(forms) {
+    const words = [...new Set(forms.map(form => form.trim()).filter(Boolean))].sort((a, b) => b.length - a.length);
+    if (!words.length)
+        throw new Error('reguła done_when: wymagana co najmniej jedna forma roli innej niż Worker');
+    return new RegExp(`${WORD_START}(?:${words.map(escape).join('|')})${WORD_END}`, 'gu');
+}
+function roleAction(text, roleAt) {
+    for (const match of text.matchAll(roleAt)) {
+        const start = match.index, end = start + match[0].length;
+        if (ACTION_AFTER_ROLE.test(text.slice(end, end + 200))
+            || PASSIVE_BEFORE_ROLE.test(text.slice(Math.max(0, start - 100), start))
+            || ACTION_BEFORE_ROLE.test(text.slice(Math.max(0, start - 60), start)))
+            return match[0];
+    }
+    return null;
+}
+/** Dowód działającego systemu należy do odbioru po landzie. Test opisujący taki przypadek nadal jest lokalnym kryterium. */
+function liveAction(text) {
+    if (/^\s*(?:test|fixture|mock|symulacj)\p{L}*\s+(?:sprawdza|odtwarza|symuluje|weryfikuje)/iu.test(text))
+        return null;
+    return /(?:\bCI\b[^.;\n]{0,60}(?:exact[ -]SHA|(?:na|dla)\s+(?:tym\s+SHA|HEAD|kandydata))|(?:realn|rzeczywist)\p{L}*\s+(?:budzeni|wybudzeni)\p{L}*|(?:działa|wdrożon\p{L}*|potwierdzon\p{L}*)[^.;\n]{0,35}(?:na\s+produkcji|\bprod\b))/iu.test(text) ? 'pipeline/live' : null;
+}
+/** Reguła dla ról instancji: pozycje done_when wymagające cudzej czynności lub dowodu live. Nie-stringi pomija. */
+export function nonWorkerDoneWhenFor(forms) {
+    const roleAt = roleMatcher(forms);
+    return doneWhen => {
+        const items = typeof doneWhen === 'string' ? [doneWhen] : Array.isArray(doneWhen) ? doneWhen : [];
+        return items.flatMap((item, index) => {
+            const role = typeof item === 'string' ? roleAction(item, roleAt) ?? liveAction(item) : null;
+            return role === null ? [] : [{ index, role, excerpt: String(item).replace(/\s+/g, ' ').slice(0, 90) }];
+        });
+    };
+}
+/** Odmowa dla done_when wymagającego cudzej czynności lub dowodu live; null = brak zastrzeżeń. */
+export function nonWorkerRefusal(rule, doneWhen) {
+    const [first] = rule(doneWhen);
+    if (!first)
+        return null;
+    return {
+        reason: first.role === 'pipeline/live'
+            ? `done_when[${first.index}]: dowód live — przenieś do effect_check / odbioru po landzie`
+            : `done_when[${first.index}]: akcja roli innej niż Worker (${first.role})`,
+        index: first.index, role: first.role, excerpt: first.excerpt,
+        doneWhenSha: createHash('sha256').update(JSON.stringify(doneWhen)).digest('hex'),
+    };
+}
+/** Sam powód odmowy (string) — jak `nonWorkerDoneWhenReason` w oryginale. */
+export function nonWorkerDoneWhenReason(rule, doneWhen) {
+    return nonWorkerRefusal(rule, doneWhen)?.reason ?? null;
+}

package/dist/intent-rules/hooks.d.ts

@@ -0,0 +1,29 @@
+import { type RolesConfig } from '../engine-config.js';
+import { type NonWorkerItem } from './done-when-roles.js';
+export type DoneWhenFinding = NonWorkerItem;
+export interface AuthorityClass {
+    kind: string;
+}
+export interface MachineFieldProblem {
+    path: string;
+    expectedFormat: string;
+}
+export interface AuthorityInput {
+    id: string;
+    title: string;
+    details: Record<string, unknown>;
+}
+export interface CompilerHooks {
+    nonWorkerDoneWhen(doneWhen: unknown): DoneWhenFinding[];
+    classifyAuthority(card: AuthorityInput): AuthorityClass;
+    machineFieldProblem(meta: Record<string, unknown>, projectId: string): MachineFieldProblem | null;
+}
+export declare function classifyAuthority(card: AuthorityInput): AuthorityClass;
+export interface HookSettings {
+    roles: RolesConfig;
+    expectationProject?: string;
+}
+/** Domyślne reguły kompilatora dla ról i ustawień instancji. */
+export declare function hooksFor(settings: HookSettings): CompilerHooks;
+/** Reguły z domyślnymi (neutralnymi) rolami produktu. */
+export declare const defaultHooks: CompilerHooks;

package/dist/intent-rules/hooks.js

@@ -0,0 +1,23 @@
+// Reguły, które oryginał importował z repo robisie-app, przeniesione do pakietu:
+//   nonWorkerDoneWhen   ← app/maszynista/done-when-roles   (src/done-when-roles.ts; role z robisie.config.json)
+//   machineFieldProblem ← app/src/lib/planner/admission    (src/admission.ts; projekt oczekiwań z konfiguracji)
+//   classifyAuthority   ← app/maszynista/lib
+// classifyAuthority: oryginał przy jawnym details.authority=auto|human zwraca dokładnie tę wartość (lib.ts:595–597), a kompilator
+// odrzuca każdą inną wartość authority przed zapisem payloadu — więc dla każdej przyjętej intencji wynik jest ten sam co tutaj.
+// Hooki można nadal podmienić przez API (`compileIntent(..., {hooks})`), ale domyślne reguły działają także w CLI.
+import { machineFieldProblem as admissionProblem } from './admission.js';
+import { DEFAULT_ROLES, nonWorkerRoleForms } from '../engine-config.js';
+import { nonWorkerDoneWhenFor } from './done-when-roles.js';
+export function classifyAuthority(card) {
+    return { kind: String(card.details.authority) };
+}
+/** Domyślne reguły kompilatora dla ról i ustawień instancji. */
+export function hooksFor(settings) {
+    return {
+        nonWorkerDoneWhen: nonWorkerDoneWhenFor(nonWorkerRoleForms(settings.roles)),
+        classifyAuthority,
+        machineFieldProblem: (meta, projectId) => admissionProblem(meta, projectId, settings.expectationProject),
+    };
+}
+/** Reguły z domyślnymi (neutralnymi) rolami produktu. */
+export const defaultHooks = hooksFor({ roles: DEFAULT_ROLES });

package/dist/k3-codex-role.d.ts

@@ -0,0 +1,20 @@
+import { type SpawnSyncOptionsWithStringEncoding, type SpawnSyncReturns } from "node:child_process";
+type RoleBundle = {
+    disposition: string;
+    instructions: string;
+    execution: {
+        provider: string;
+        model: string;
+        effort: string;
+    };
+};
+export interface K3CodexRoleOptions {
+    binary: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    sandbox: "read-only" | "workspace-write";
+    timeoutMs: number;
+}
+/** Runs a prepared role once; process success is not a review verdict. */
+export declare function runK3CodexRole(bundle: RoleBundle, options: K3CodexRoleOptions, spawn?: (binary: string, argv: readonly string[], options: SpawnSyncOptionsWithStringEncoding) => SpawnSyncReturns<string>): SpawnSyncReturns<string>;
+export {};

package/dist/k3-codex-role.js

@@ -0,0 +1,68 @@
+import { spawnSync } from "node:child_process";
+import { isAbsolute } from "node:path";
+function requireObject(value, field) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`K3 Codex: ${field} must be an object`);
+    }
+}
+function requireText(value, field, absolute = false) {
+    if (typeof value !== "string" || !value.trim() || (absolute && !isAbsolute(value))) {
+        throw new Error(`K3 Codex: ${field} must be a nonempty ${absolute ? "absolute path" : "string"}`);
+    }
+}
+function diagnostics(value) {
+    const read = (key) => {
+        try {
+            return typeof value === "object" && value !== null ? value[key] : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const status = read("status");
+    const signal = read("signal");
+    const code = read("code");
+    return `status=${typeof status === "number" && Number.isSafeInteger(status) ? status : null}; `
+        + `signal=${signal === "SIGTERM" || signal === "SIGKILL" ? signal : null}; `
+        + `code=${code === "ETIMEDOUT" || code === "ENOENT" || code === "EACCES" ? code : null}`;
+}
+/** Runs a prepared role once; process success is not a review verdict. */
+export function runK3CodexRole(bundle, options, spawn = spawnSync) {
+    requireObject(bundle, "bundle");
+    requireObject(bundle.execution, "execution");
+    requireObject(options, "options");
+    requireObject(options.env, "env");
+    if (bundle.disposition !== "READY")
+        throw new Error("K3 Codex: disposition must be READY");
+    if (bundle.execution.provider !== "codex")
+        throw new Error("K3 Codex: provider must be codex");
+    requireText(bundle.instructions, "instructions");
+    requireText(bundle.execution.model, "model");
+    requireText(bundle.execution.effort, "effort");
+    requireText(options.binary, "binary", true);
+    requireText(options.cwd, "cwd", true);
+    requireText(options.env.HOME, "HOME");
+    requireText(options.env.PATH, "PATH");
+    requireText(options.env.CODEX_HOME, "CODEX_HOME", true);
+    if (options.sandbox !== "read-only" && options.sandbox !== "workspace-write") {
+        throw new Error("K3 Codex: sandbox must be read-only or workspace-write");
+    }
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0) {
+        throw new Error("K3 Codex: timeoutMs must be a positive safe integer");
+    }
+    const argv = ["exec", "--json", "--ephemeral", "--skip-git-repo-check", "--ignore-user-config", "--ignore-rules",
+        "--model", bundle.execution.model, "-c", `model_reasoning_effort=${JSON.stringify(bundle.execution.effort)}`,
+        "-C", options.cwd, "-s", options.sandbox, "-"];
+    let result;
+    try {
+        result = spawn(options.binary, argv, { input: bundle.instructions, encoding: "utf8", cwd: options.cwd,
+            env: options.env, timeout: options.timeoutMs, shell: false, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024 });
+    }
+    catch (error) {
+        throw new Error(`K3 Codex process threw: ${diagnostics(error)}`);
+    }
+    if (result.status !== 0 || result.signal || result.error) {
+        throw new Error(`K3 Codex process failed: ${diagnostics(result)}${result.error ? `; ${diagnostics(result.error)}` : ""}`);
+    }
+    return result;
+}

package/dist/manifest.d.ts

@@ -0,0 +1,41 @@
+import { type AgentId } from "./agents.js";
+import type { RoleKind } from "./roles.js";
+import { type Entry } from "./fsops.js";
+/**
+ * The package's own directory (`$XDG_CONFIG_HOME/robisie`, default `~/.config/robisie`): key, manifest,
+ * backups and Codex role files. The package creates it and is its only owner — nothing else lives there,
+ * and uninstall still deletes only the files it recorded (never recursively).
+ */
+export interface Manifest {
+    packageVersion: string;
+    agents: AgentId[];
+    entries: Entry[];
+    /** Kept raw so doctor and uninstall can still inspect entries when the map is damaged. */
+    roleProviders?: unknown;
+}
+export declare const ROLE_IDS: readonly ["ceo", "builder", "quality"];
+export type RoleProviders = Record<RoleKind, AgentId>;
+export declare const ROLE_STEP = "U\u017Cyj pe\u0142nej jednolitej mapy: `npx robisie init --agent codex --role ceo=codex --role builder=codex --role quality=codex` (role: ceo, builder, quality; dostawcy: claude, codex, opencode).";
+/** Legacy single-provider installs have one unambiguous assignment; explicit null stays null. */
+export declare function roleProviders(manifest: Pick<Manifest, "agents" | "roleProviders">): RoleProviders | null;
+export declare function clientPaths(dir: string): {
+    dir: string;
+    manifest: string;
+    key: string;
+    backups: string;
+    roles: string;
+    codexRoles: string;
+};
+/** Refuse symlinks at owned paths; ancestors such as XDG_CONFIG_HOME may be symlinks. */
+export declare function refuseSymlink(path: string): void;
+/** Ensure the package directory is private (0700) — parents keep their normal mode. */
+export declare function ensurePrivateDir(dir: string): void;
+/**
+ * Atomic private write: a fresh temp file created exclusively (O_EXCL, 0600) next to the target, then
+ * rename. Either the old or the new content is on disk — never half of it — and a symlink is never followed.
+ */
+export declare function writePrivate(dir: string, path: string, text: string): void;
+export declare function readManifest(path: string): Manifest | null;
+export declare function writeManifest(dir: string, manifest: Omit<Manifest, "packageVersion">): void;
+export declare function writeKey(dir: string, key: string): void;
+export declare function readKey(dir: string): string | null;

package/dist/manifest.js

@@ -1,11 +1,12 @@
-import { closeSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeSync } from "node:fs";
+import { chmodSync, closeSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { basename, dirname, join } from "node:path";
 import { PACKAGE_VERSION } from "./constants.js";
-import { RobisieError, errorMessage } from "./context.js";
+import { RobisieError, errorMessage, shellQuote } from "./context.js";
 import { isAgentId } from "./agents.js";
+import { freeCopyPath } from "./fsops.js";
 export const ROLE_IDS = ["ceo", "builder", "quality"];
-export const ROLE_STEP = "Użyj --role ceo=claude --role builder=codex --role quality=opencode (role: ceo, builder, quality; dostawcy: claude, codex, opencode).";
+export const ROLE_STEP = "Użyj pełnej jednolitej mapy: `npx robisie init --agent codex --role ceo=codex --role builder=codex --role quality=codex` (role: ceo, builder, quality; dostawcy: claude, codex, opencode).";
 /** Legacy single-provider installs have one unambiguous assignment; explicit null stays null. */
 export function roleProviders(manifest) {
     if (!Object.hasOwn(manifest, "roleProviders")) {
@@ -21,7 +22,7 @@ export function roleProviders(manifest) {
             const provider = value[role];
             return Object.hasOwn(value, role) && typeof provider === "string" && isAgentId(provider);
         })) {
-        throw new RobisieError("Mapa roleProviders jest uszkodzona lub niekompletna (ceo, builder, quality).", `Przywróć poprawną mapę roleProviders w manifest.json z kopii albo ustaw null. ${ROLE_STEP}`);
+        throw new RobisieError("Mapa roleProviders jest uszkodzona lub niekompletna (ceo, builder, quality).", `Przywróć poprawną mapę roleProviders w manifest.json z kopii albo ustaw wyłącznie pole roleProviders na null w manifest.json, zachowując agents i entries. ${ROLE_STEP}`);
     }
     return value;
 }
@@ -48,23 +49,45 @@ function isSymlink(path) {
 /** Refuse symlinks at owned paths; ancestors such as XDG_CONFIG_HOME may be symlinks. */
 export function refuseSymlink(path) {
     if (isSymlink(path)) {
-        throw new RobisieError(`${path} jest dowiązaniem symbolicznym — nie korzystam z niego jako pliku ani katalogu robisie.`, `Wskaż zwykły katalog przez XDG_CONFIG_HOME i uruchom polecenie ponownie.`);
+        let sourceAvailable = false;
+        let directorySource = null;
+        try {
+            const source = statSync(path);
+            sourceAvailable = source.isFile();
+            if (source.isDirectory())
+                directorySource = realpathSync(path);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw new RobisieError(`Nie mogę sprawdzić źródła ${path}: ${errorMessage(error)}`, `Sprawdź uprawnienia do ${path}.`);
+        }
+        const copy = freeCopyPath(path);
+        throw new RobisieError(`${path} jest dowiązaniem symbolicznym — nie korzystam z niego jako pliku ani katalogu robisie.`, directorySource
+            ? `Zachowaj dowiązanie i skopiuj dostępny katalog: \`mv -n -- ${shellQuote(path)} ${shellQuote(copy)} && cp -R -- ${shellQuote(directorySource)} ${shellQuote(path)}\` (cel i istniejące kopie pozostają). Potem ponów poprzednie polecenie robisie w tym samym katalogu konfiguracji.`
+            : sourceAvailable
+                ? `Zamień dowiązanie na zwykły plik: \`cp ${shellQuote(path)} ${shellQuote(copy)} && mv ${shellQuote(copy)} ${shellQuote(path)}\` (cel i istniejące kopie pozostają). Potem ponów poprzednie polecenie robisie w tym samym katalogu konfiguracji.`
+                : `Brak zwykłego pliku źródłowego. Przywróć ${path} jako zwykły plik lub katalog z poprawnej kopii tej samej instalacji, zachowując dowiązanie i jego cel. Bez dostępnego źródła nie można bezpiecznie kontynuować; zmiana katalogu konfiguracji nie naprawi starej ewidencji.`);
     }
 }
-/** Create the package directory (0700) — parents keep their normal mode. */
+/** Ensure the package directory is private (0700) — parents keep their normal mode. */
 export function ensurePrivateDir(dir) {
     refuseSymlink(dir);
     try {
         mkdirSync(dirname(dir), { recursive: true });
         mkdirSync(dir, { recursive: true, mode: 0o700 });
+        refuseSymlink(dir);
+        const stat = lstatSync(dir);
+        if (!stat.isDirectory()) {
+            throw new RobisieError(`${dir} nie jest katalogiem.`, `Przenieś ${dir} w inne miejsce i uruchom polecenie ponownie.`);
+        }
+        if ((stat.mode & 0o7777) !== 0o700)
+            chmodSync(dir, 0o700);
     }
     catch (error) {
+        if (error instanceof RobisieError)
+            throw error;
         throw new RobisieError(`Nie mogę utworzyć katalogu ${dir}: ${errorMessage(error)}`, `Sprawdź uprawnienia do katalogu ${dirname(dir)}.`);
     }
-    refuseSymlink(dir);
-    if (!lstatSync(dir).isDirectory()) {
-        throw new RobisieError(`${dir} nie jest katalogiem.`, `Przenieś ${dir} w inne miejsce i uruchom polecenie ponownie.`);
-    }
 }
 /**
  * Atomic private write: a fresh temp file created exclusively (O_EXCL, 0600) next to the target, then
@@ -111,6 +134,26 @@ export function writePrivate(dir, path, text) {
         throw new RobisieError(`Nie mogę zapisać ${path}: ${errorMessage(error)}`, `Sprawdź uprawnienia do katalogu ${dir}.`);
     }
 }
+function isEntry(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const entry = value;
+    if (typeof entry.path !== "string" || (entry.backup !== null && typeof entry.backup !== "string"))
+        return false;
+    switch (entry.kind) {
+        case "file":
+            return (entry.mode === null || typeof entry.mode === "number") &&
+                (!Object.hasOwn(entry, "fingerprint") || typeof entry.fingerprint === "string");
+        case "block":
+            return (entry.comment === "hash" || entry.comment === "html") && typeof entry.created === "boolean";
+        case "json":
+            return Array.isArray(entry.keyPath) && entry.keyPath.every((key) => typeof key === "string") &&
+                typeof entry.created === "boolean" && typeof entry.fingerprint === "string" &&
+                (entry.mode === null || typeof entry.mode === "number");
+        default:
+            return false;
+    }
+}
 export function readManifest(path) {
     refuseSymlink(dirname(path));
     refuseSymlink(path);
@@ -125,14 +168,14 @@ export function readManifest(path) {
     }
     try {
         const parsed = JSON.parse(text);
-        if (!Array.isArray(parsed.entries) || !Array.isArray(parsed.agents))
+        if (!Array.isArray(parsed.entries) || !parsed.entries.every(isEntry) || !Array.isArray(parsed.agents))
             throw new Error("brak pól");
         const manifest = { packageVersion: String(parsed.packageVersion ?? "?"), agents: parsed.agents, entries: parsed.entries };
         manifest.roleProviders = Object.hasOwn(parsed, "roleProviders") ? parsed.roleProviders : roleProviders(manifest);
         return manifest;
     }
     catch {
-        throw new RobisieError(`Plik ${path} jest uszkodzony.`, `Przenieś ${path} w inne miejsce i uruchom \`npx robisie init\` ponownie.`);
+        throw new RobisieError(`Plik ${path} jest uszkodzony.`, `Przywróć ${path} z poprawnej kopii ewidencji tej samej instalacji, zachowując uszkodzony plik w osobnej kopii. Bez poprawnej kopii brakuje ewidencji potrzebnej do bezpiecznego init/uninstall — zatrzymaj się i skontaktuj się z robisie; nowy init jej nie odtworzy.`);
     }
 }
 export function writeManifest(dir, manifest) {
@@ -150,7 +193,9 @@ export function readKey(dir) {
     try {
         return readFileSync(path, "utf8").trim() || null;
     }
-    catch {
-        return null;
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw new RobisieError(`Nie mogę odczytać pliku ${path} (błąd IO).`, `Sprawdź prawa odczytu pliku ${path}. Jeśli nie jest zwykłym plikiem, przywróć go z poprawnej kopii tej samej instalacji, zachowując istniejący plik lub katalog i jego zawartość w osobnej kopii. Potem wczytaj ROBISIE_KEY zgodnie z instrukcją instalacji i ponów \`npx robisie doctor\`.`);
     }
 }

package/dist/mcp.d.ts

@@ -0,0 +1,18 @@
+import { type Ctx } from "./context.js";
+/** Major of a semver string, or null when it is not one. */
+export declare function majorOf(version: string): number | null;
+/** Throws a RobisieError when the server's contract MAJOR is not the one this package speaks. */
+export declare function assertCompatible(serverVersion: string | null): void;
+/** Public, unauthenticated: the contract version the server announces in /.well-known/mcp.json. */
+export declare function fetchContractVersion(ctx: Ctx): Promise<string | null>;
+export interface RpcResult {
+    result: unknown;
+    contractVersion: string | null;
+}
+export interface Connection {
+    serverName: string;
+    contractVersion: string | null;
+    projectCount: number;
+}
+/** initialize + list_projects: proves the key works end-to-end and reads the board. */
+export declare function checkConnection(ctx: Ctx, key: string): Promise<Connection>;

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import { CONTRACT_VERSION_HEADER, PACKAGE_NAME, PACKAGE_VERSION, SUPPORTED_CONTRACT_MAJOR, mcpUrl, wellKnownUrl } from "./constants.js";
-import { RobisieError, errorMessage } from "./context.js";
+import { RobisieError } from "./context.js";
 const TIMEOUT_MS = 15_000;
-const UPDATE_STEP = "Uzyskaj od zespołu plik .tgz zgodny z kontraktem serwera; w katalogu instalacji wykonaj `npm i ./robisie-0.1.0.tgz` (użyj nazwy zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`.";
+const UPDATE_STEP = "Zainstaluj z npm aktualną paczkę zgodną z kontraktem serwera; w katalogu instalacji wykonaj `npm i robisie@latest`, potem lokalne `npx robisie init` i `npx robisie doctor`.";
 /** Major of a semver string, or null when it is not one. */
 export function majorOf(version) {
     const match = /^(\d+)\.\d+\.\d+/.exec(version.trim());
@@ -15,15 +15,15 @@ export function assertCompatible(serverVersion) {
     const major = majorOf(serverVersion);
     if (major === SUPPORTED_CONTRACT_MAJOR)
         return;
-    const newer = major !== null && major > SUPPORTED_CONTRACT_MAJOR;
-    throw new RobisieError(`Wersja kontraktu serwera (${serverVersion}) nie pasuje do paczki ${PACKAGE_NAME} ${PACKAGE_VERSION} (obsługuje ${SUPPORTED_CONTRACT_MAJOR}.x).`, newer ? UPDATE_STEP : "Serwer jest starszy niż paczka. Uzyskaj od zespołu plik .tgz zgodny z kontraktem serwera; w katalogu instalacji wykonaj `npm i ./robisie-0.1.0.tgz` (użyj nazwy zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+    const older = major !== null && major < SUPPORTED_CONTRACT_MAJOR;
+    throw new RobisieError(`Wersja kontraktu serwera (${serverVersion}) nie pasuje do paczki ${PACKAGE_NAME} ${PACKAGE_VERSION} (obsługuje ${SUPPORTED_CONTRACT_MAJOR}.x).`, older ? "Serwer jest starszy niż paczka. Zainstaluj z npm wydanie zgodne z kontraktem serwera: `npm i robisie@<wersja-zgodna-z-kontraktem-serwera>` (zastąp placeholder numerem zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`." : UPDATE_STEP);
 }
 async function request(ctx, url, init) {
     try {
-        return await ctx.fetch(url, { ...init, signal: AbortSignal.timeout(TIMEOUT_MS) });
+        return await ctx.fetch(url, { ...init, redirect: "error", signal: AbortSignal.timeout(TIMEOUT_MS) });
     }
-    catch (error) {
-        throw new RobisieError(`Brak połączenia z ${new URL(url).host}: ${errorMessage(error)}`, "Sprawdź internet (albo proxy/firewall) i spróbuj ponownie.");
+    catch {
+        throw new RobisieError(`Brak połączenia z ${new URL(url).host}.`, "Sprawdź internet (albo proxy/firewall) i spróbuj ponownie.");
     }
 }
 /** Public, unauthenticated: the contract version the server announces in /.well-known/mcp.json. */
@@ -41,37 +41,68 @@ export async function fetchContractVersion(ctx) {
         return null;
     }
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function formatError() {
+    return new RobisieError("Serwer robisie odpowiedział w nieznanym formacie.", UPDATE_STEP);
+}
 /** Streamable HTTP answers either plain JSON or an SSE stream; pick our response out of either. */
 async function readRpc(res, id) {
-    const text = await res.text();
-    const candidates = [];
-    if ((res.headers.get("content-type") ?? "").includes("text/event-stream")) {
-        for (const event of text.split(/\r?\n\r?\n/)) {
-            const data = event
-                .split(/\r?\n/)
-                .filter((line) => line.startsWith("data:"))
-                .map((line) => line.slice(5).trimStart())
-                .join("\n");
-            if (data)
-                candidates.push(data);
-        }
-    }
-    else {
-        candidates.push(text);
-    }
-    for (const candidate of candidates) {
+    const matching = (candidate) => {
         try {
             const parsed = JSON.parse(candidate);
             for (const message of Array.isArray(parsed) ? parsed : [parsed]) {
-                if (typeof message === "object" && message !== null && message.id === id)
+                if (isRecord(message) && message.id === id)
                     return message;
             }
         }
         catch {
             // not JSON — skip this event
         }
+        return null;
+    };
+    let reader;
+    try {
+        if (!(res.headers.get("content-type") ?? "").includes("text/event-stream"))
+            return matching(await res.text());
+        if (!res.body)
+            return null;
+        reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                return null; // EOF never completes an unterminated SSE event.
+            buffer += decoder.decode(value, { stream: true });
+            let boundary;
+            while ((boundary = /\r?\n\r?\n/.exec(buffer)) !== null) {
+                const event = buffer.slice(0, boundary.index);
+                buffer = buffer.slice(boundary.index + boundary[0].length);
+                const data = event.split(/\r?\n/)
+                    .filter((line) => line.startsWith("data:"))
+                    .map((line) => line.slice(5).trimStart())
+                    .join("\n");
+                const message = matching(data);
+                if (message)
+                    return message;
+            }
+        }
+    }
+    catch {
+        throw new RobisieError("Nie mogę odczytać odpowiedzi serwera robisie.", "Sprawdź połączenie i uruchom ponownie `npx robisie doctor`.");
+    }
+    finally {
+        if (reader) {
+            // Cancellation may never settle; release ownership without delaying the RPC result.
+            void reader.cancel().catch(() => { });
+            reader.releaseLock();
+        }
     }
-    return null;
 }
 async function rpc(ctx, key, id, method, params) {
     const res = await request(ctx, mcpUrl(ctx.origin), {
@@ -93,10 +124,13 @@ async function rpc(ctx, key, id, method, params) {
     if (!res.ok)
         throw new RobisieError(`Serwer robisie odpowiedział błędem ${res.status}.`, "Spróbuj ponownie za kilka minut; jeśli błąd zostaje, napisz do robisie.");
     const message = await readRpc(res, id);
-    if (!message)
-        throw new RobisieError("Serwer robisie odpowiedział w nieznanym formacie.", UPDATE_STEP);
-    if (message.error)
-        throw new RobisieError(`Serwer robisie zwrócił błąd: ${message.error.message}`, "Spróbuj ponownie; jeśli błąd zostaje, uruchom lokalne `npx robisie doctor` w katalogu instalacji.");
+    if (!message || message.jsonrpc !== "2.0" || ("result" in message) === ("error" in message))
+        throw formatError();
+    if ("error" in message) {
+        if (!isRecord(message.error) || !Number.isInteger(message.error.code) || typeof message.error.message !== "string")
+            throw formatError();
+        throw new RobisieError("Serwer robisie zwrócił błąd RPC.", "Spróbuj ponownie; jeśli błąd zostaje, uruchom lokalne `npx robisie doctor` w katalogu instalacji.");
+    }
     return { result: message.result, contractVersion };
 }
 /** initialize + list_projects: proves the key works end-to-end and reads the board. */
@@ -106,22 +140,38 @@ export async function checkConnection(ctx, key) {
         capabilities: {},
         clientInfo: { name: PACKAGE_NAME, version: PACKAGE_VERSION },
     });
-    const serverInfo = init.result?.serverInfo;
+    if (!isRecord(init.result) || !isRecord(init.result.serverInfo) || !nonEmptyString(init.result.serverInfo.name)
+        || !nonEmptyString(init.result.protocolVersion) || !isRecord(init.result.capabilities))
+        throw formatError();
+    const serverName = init.result.serverInfo.name;
     const list = await rpc(ctx, key, 2, "tools/call", { name: "list_projects", arguments: {} });
     const result = list.result;
-    if (result?.isError)
-        throw new RobisieError(`Narzędzie list_projects zwróciło błąd: ${result.content?.[0]?.text ?? "brak opisu"}`, "Spróbuj ponownie; jeśli błąd zostaje, napisz do robisie.");
-    let projectCount = 0;
+    if (!isRecord(result) || (result.isError !== undefined && typeof result.isError !== "boolean"))
+        throw formatError();
+    if (result.isError)
+        throw new RobisieError("Narzędzie list_projects zwróciło błąd.", "Spróbuj ponownie; jeśli błąd zostaje, napisz do robisie.");
+    if (!Array.isArray(result.content))
+        throw formatError();
+    const content = result.content.find((item) => isRecord(item) && item.type === "text");
+    if (!isRecord(content) || typeof content.text !== "string")
+        throw formatError();
+    let parsed;
     try {
-        const parsed = JSON.parse(result?.content?.[0]?.text ?? "[]");
-        projectCount = Array.isArray(parsed) ? parsed.length : 0;
+        parsed = JSON.parse(content.text);
     }
     catch {
-        projectCount = 0;
+        throw formatError();
     }
+    if (!Array.isArray(parsed) || !parsed.every((project) => isRecord(project)
+        && nonEmptyString(project.id) && nonEmptyString(project.name)))
+        throw formatError();
+    if (init.contractVersion)
+        assertCompatible(init.contractVersion);
+    if (list.contractVersion)
+        assertCompatible(list.contractVersion);
     return {
-        serverName: typeof serverInfo?.name === "string" ? serverInfo.name : "?",
+        serverName,
         contractVersion: init.contractVersion ?? list.contractVersion,
-        projectCount,
+        projectCount: parsed.length,
     };
 }