robisie 0.1.0 → 0.1.1

package/dist/fsops.js

@@ -3,16 +3,25 @@ import { chmodSync, copyFileSync, lstatSync, mkdirSync, readFileSync, realpathSy
 import { basename, dirname, join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { parse } from "smol-toml";
+import { tomlStatements } from "./agents.js";
 import { FILE_MARK, HELPER_SERVERS, MARK_BEGIN, MARK_END, MCP_SERVER_NAME } from "./constants.js";
 import { RobisieError, errorMessage, shellQuote } from "./context.js";
-function readText(path) {
+function readText(path, strict = false) {
+    let invalidUtf8 = false;
     try {
-        return readFileSync(path, "utf8");
+        const bytes = readFileSync(path);
+        const text = bytes.toString("utf8");
+        invalidUtf8 = strict && !Buffer.from(text, "utf8").equals(bytes);
+        if (invalidUtf8)
+            throw new Error("Plik nie jest poprawnym UTF-8.");
+        return text;
     }
     catch (error) {
         if (error.code === "ENOENT")
             return null;
-        throw new RobisieError(`Nie mogę odczytać pliku ${path}: ${errorMessage(error)}`, `Sprawdź uprawnienia do pliku ${path}.`);
+        throw new RobisieError(`Nie mogę odczytać pliku ${path}: ${errorMessage(error)}`, invalidUtf8
+            ? `Zachowaj oryginalne bajty w osobnej kopii: \`cp -p -n -- ${shellQuote(path)} ${shellQuote(freeCopyPath(path))}\`. Sprawdź, że kopia powstała i zawiera oryginalne bajty. Przywróć poprawną wersję UTF-8 z pewnej kopii, zachowując cudzą konfigurację, i ponów poprzednie polecenie robisie. Bez pewnej wersji zatrzymaj się; nie zapisuj pliku ze znakami zastępczymi.`
+            : `Sprawdź uprawnienia do pliku ${path}.`);
     }
 }
 function isSymlink(path) {
@@ -73,8 +82,10 @@ export function refusePrivateSymlink(op) {
     catch {
         // dangling — the message still names the link
     }
+    if (target === "?")
+        throw new RobisieError(`${op.path} jest zerwanym dowiązaniem symbolicznym — nie zapisuję przez nie klucza.`, `Brak pliku źródłowego dla ${op.path}. Przywróć poprawny plik docelowy z własnej kopii i ponów polecenie; bez dostępnego źródła zatrzymaj się, nic nie zostało zmienione.`);
     const copy = freeCopyPath(op.path);
-    throw new RobisieError(`${op.path} jest dowiązaniem symbolicznym do ${target} — nie zapisuję przez nie klucza robisie, bo plik docelowy (np. w repozytorium dotfiles) mógłby trafić z kluczem do historii git.`, `Zamień dowiązanie na zwykły plik: \`cp ${shellQuote(op.path)} ${shellQuote(copy)} && mv ${shellQuote(copy)} ${shellQuote(op.path)}\` (treść zostaje, dowiązanie znika; nazwa kopii jest wolna, więc żadna Twoja kopia nie zostanie nadpisana), i uruchom \`npx robisie init\` ponownie. Albo pomiń tego agenta, np. \`npx robisie init --agent codex\`.`);
+    throw new RobisieError(`${op.path} jest dowiązaniem symbolicznym do ${target} — nie zapisuję przez nie klucza robisie, bo plik docelowy (np. w repozytorium dotfiles) mógłby trafić z kluczem do historii git.`, `Zamień dowiązanie na zwykły plik: \`cp ${shellQuote(op.path)} ${shellQuote(copy)} && mv ${shellQuote(copy)} ${shellQuote(op.path)}\` (treść zostaje, dowiązanie znika; nazwa kopii jest wolna, więc żadna Twoja kopia nie zostanie nadpisana), i uruchom \`npx robisie init\` ponownie.`);
 }
 /** Mode of an existing file (following links), or null when there is none. */
 function modeOf(path) {
@@ -119,7 +130,22 @@ function removeFile(path) {
 function backup(store, path) {
     const target = join(store.backupDir, `${Date.now()}-${randomBytes(3).toString("hex")}-${basename(path)}`);
     try {
-        mkdirSync(store.backupDir, { recursive: true, mode: 0o700 });
+        let directory;
+        try {
+            directory = lstatSync(store.backupDir);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            mkdirSync(store.backupDir, { recursive: true, mode: 0o700 });
+            directory = lstatSync(store.backupDir);
+        }
+        if (directory.isSymbolicLink())
+            throw new Error("Katalog kopii zapasowych jest dowiązaniem symbolicznym.");
+        if (!directory.isDirectory())
+            throw new Error("Miejsce kopii zapasowych nie jest katalogiem.");
+        if ((directory.mode & 0o777) !== 0o700)
+            chmodSync(store.backupDir, 0o700);
         copyFileSync(path, target);
         chmodSync(target, statSync(path).mode & 0o777);
     }
@@ -156,14 +182,24 @@ export function stripBlock(text, comment) {
     const [begin, end] = markerLines(comment);
     while (true) {
         const lines = text.split("\n");
-        const first = lines.findIndex((line) => line.replace(/\r$/, "") === begin);
+        const first = lines.findIndex((line) => [begin, end].includes(line.replace(/\r$/, "")));
         if (first === -1)
             return text;
-        const last = lines.findIndex((line, index) => index > first && line.replace(/\r$/, "") === end);
+        let inside = false;
+        const valid = lines.every((line) => {
+            const marker = line.replace(/\r$/, "");
+            if (marker !== begin && marker !== end)
+                return true;
+            if ((marker === begin) === inside)
+                return false;
+            inside = marker === begin;
+            return true;
+        });
+        const last = valid && !inside ? lines.findIndex((line, index) => index > first && line.replace(/\r$/, "") === end) : -1;
         if (last === -1) {
-            throw new RobisieError("Znacznik robisie w pliku jest uszkodzony (brak końca bloku).", `Usuń ręcznie linie od „${begin}” i uruchom polecenie ponownie.`);
+            throw new RobisieError("Znacznik robisie w pliku jest uszkodzony (brak końca bloku).", `Zachowaj własną kopię pliku. Przywróć poprawną parę znaczników „${begin}” i „${end}” z poprawnej kopii, zachowując wszystkie cudze bajty także za blokiem. Bez kopii lub pewnej granicy bloku zatrzymaj się; nie usuwaj treści do końca pliku.`);
         }
-        text = [...lines.slice(0, first), ...lines.slice(last + 1)].join("\n");
+        text = lines.slice(0, first).map((line) => `${line}\n`).join("") + lines.slice(last + 1).join("\n");
     }
 }
 export function hasBlock(text, comment) {
@@ -211,9 +247,27 @@ export function assertCodexChange(before, after, body) {
 }
 /** Shared by command preflight and the actual write; validate before creating a backup. */
 export function prepareBlock(current, comment, clean, body) {
-    let base = stripBlock(current ?? "", comment);
-    if (clean)
+    let base = current ?? "";
+    if (clean) {
+        // TOML statements keep multiline values intact: only standalone marker lines are ours.
+        const [begin, end] = markerLines(comment);
+        let inside = false;
+        const malformed = () => new RobisieError("Znaczniki robisie w config.toml są uszkodzone (brak pary, odwrócenie lub zagnieżdżenie).", "Popraw pary znaczników robisie w config.toml, zachowując swoją konfigurację, i ponów polecenie.");
+        base = tomlStatements(base).filter((statement) => {
+            const line = statement.replace(/\r?\n$/, "");
+            if (line !== begin && line !== end)
+                return true;
+            if ((line === begin) === inside)
+                throw malformed();
+            inside = line === begin;
+            return false;
+        }).join("");
+        if (inside)
+            throw malformed();
         base = clean(base);
+    }
+    else
+        base = stripBlock(base, comment);
     const next = body === undefined ? base : withBlock(base, renderBlock(comment, body));
     if (clean)
         assertCodexChange(current ?? "", next, body);
@@ -320,14 +374,14 @@ export function restore(captured) {
 // ── apply / undo ─────────────────────────────────────────────────────────────
 /** Apply one op. `prior` is this path's entry from an earlier init (idempotence: no second backup). */
 export function applyOp(op, prior, store) {
-    const current = readText(op.path);
+    const current = readText(op.path, op.kind !== "file");
     const originalMode = prior && "mode" in prior ? prior.mode : modeOf(op.path);
     if (op.kind === "file") {
         if (isSymlink(op.path)) {
             throw new RobisieError(`${op.path} jest dowiązaniem symbolicznym — nie podmieniam go plikiem roli.`, `Przenieś albo usuń dowiązanie ${op.path} i uruchom polecenie ponownie.`);
         }
         if (current !== null && prior?.kind === "file" && prior.fingerprint !== undefined && textDigest(current) !== prior.fingerprint) {
-            throw new RobisieError(`Plik ${op.path} został zmieniony poza robisie — zostawiam go.`, `Kopie zapasowe: ${store.backupDir}. Zachowaj swoje zmiany w osobnej kopii, usuń plik ${op.path} i uruchom \`npx robisie init\` ponownie. Potem przenieś swoje zmiany do nowej roli.`);
+            throw new RobisieError(`Plik ${op.path} został zmieniony poza robisie — zostawiam go.`, `Kopie zapasowe: ${store.backupDir}. ${preserveFileStep(op.path)} To plik zarządzany przez robisie. Uruchom \`npx robisie init\` ponownie i wykonaj jego dalsze instrukcje do \`npx robisie doctor\`. Własne zmiany zachowaj w kopii poza zarządzanym plikiem; nie przenoś ich z powrotem. Kopia nie przywraca ich działania jako instrukcji roli.`);
         }
         let backupPath = prior?.kind === "file" ? prior.backup : null;
         if (current !== null && !prior && !(current.includes(FILE_MARK) && current === op.content))
@@ -351,9 +405,10 @@ export function applyOp(op, prior, store) {
     const obj = current === null ? {} : parseJson(op.path, current);
     const next = editJson(current ?? "{}\n", op.keyPath, op.value, obj);
     const changed = next !== current;
+    const modeChanged = op.private && modeOf(op.path) !== 0o600;
     const copy = current !== null && (changed || !priorJson) ? backup(store, op.path) : null;
     const backupPath = priorJson ? priorJson.backup : copy;
-    if (changed)
+    if (changed || modeChanged)
         writeText(op.path, next, op.private ? 0o600 : undefined);
     const entry = {
         kind: "json",
@@ -364,11 +419,52 @@ export function applyOp(op, prior, store) {
         fingerprint: fingerprint(op.value),
         mode: originalMode,
     };
-    return { entry, changed };
+    return { entry, changed: changed || modeChanged };
+}
+export function preserveFileStep(path) {
+    return `Zachowaj plik w osobnej kopii: \`mv -n -- ${shellQuote(path)} ${shellQuote(freeCopyPath(path))}\`.`;
+}
+/** Read-only preflight for advice: do not send init into a predictable refusal. */
+export function checkRecovery(op, prior) {
+    refusePrivateSymlink(op);
+    if (isSymlink(op.path)) {
+        if (op.kind === "file")
+            throw new RobisieError(`${op.path} jest dowiązaniem symbolicznym — rola wymaga zwykłego pliku.`, `${preserveFileStep(op.path)} Potem uruchom \`npx robisie init\`.`);
+        writeTarget(op.path); // A dangling shared link has no writable target.
+    }
+    const parent = dirname(op.path);
+    try {
+        if (!statSync(parent).isDirectory())
+            throw new RobisieError(`${parent} jest plikiem zamiast katalogu.`, `${preserveFileStep(parent)} Potem uruchom \`npx robisie init\`.`);
+    }
+    catch (error) {
+        if (error instanceof RobisieError)
+            throw error;
+        if (error.code !== "ENOENT")
+            throw new RobisieError(`Nie mogę sprawdzić katalogu ${parent}: ${errorMessage(error)}`, `Sprawdź uprawnienia do ${parent}.`);
+    }
+    const current = readText(op.path, op.kind !== "file");
+    if (current === null)
+        return;
+    if (op.kind === "file" && prior?.kind === "file" && prior.fingerprint !== undefined && textDigest(current) !== prior.fingerprint) {
+        throw new RobisieError(`Plik ${op.path} został zmieniony poza robisie — zostawiam go.`, `${preserveFileStep(op.path)} To plik zarządzany przez robisie. Uruchom \`npx robisie init\` ponownie i wykonaj jego dalsze instrukcje do \`npx robisie doctor\`. Własne zmiany zachowaj w kopii poza zarządzanym plikiem; nie przenoś ich z powrotem. Kopia nie przywraca ich działania jako instrukcji roli.`);
+    }
+    if (op.kind === "json") {
+        try {
+            parseJson(op.path, current);
+        }
+        catch (error) {
+            if (!(error instanceof RobisieError))
+                throw error;
+            throw new RobisieError(error.message, `${preserveFileStep(op.path)} Cudze bajty pozostają w kopii; potem uruchom \`npx robisie init\`.`);
+        }
+    }
+    if (op.kind === "block")
+        prepareBlock(current, op.comment, op.clean, op.body);
 }
 /** Whether what init wrote is still in place (doctor). */
 export function entryPresent(entry) {
-    const text = readText(entry.path);
+    const text = readText(entry.path, entry.kind !== "file");
     if (text === null)
         return false;
     if (entry.kind === "file")
@@ -385,7 +481,7 @@ export function entryPresent(entry) {
 }
 /** Revert one entry. A file robisie no longer recognises is left untouched, with a warning. */
 export function undoEntry(entry, clean) {
-    const current = readText(entry.path);
+    const current = readText(entry.path, entry.kind !== "file");
     const restoreMode = "mode" in entry ? entry.mode ?? undefined : undefined;
     if (entry.kind === "file") {
         if (isSymlink(entry.path))
@@ -409,12 +505,9 @@ export function undoEntry(entry, clean) {
     if (entry.kind === "block") {
         let base = prepareBlock(current, entry.comment, clean);
         // Only undo a separator inserted for an original file without its final newline.
-        let original = entry.backup ? readText(entry.backup) : null;
-        if (original !== null) {
-            original = stripBlock(original, entry.comment);
-            if (clean)
-                original = clean(original);
-        }
+        let original = entry.backup ? readText(entry.backup, true) : null;
+        if (original !== null)
+            original = prepareBlock(original, entry.comment, clean);
         if (original !== null && !original.endsWith("\n") && base === `${original}\n`)
             base = original;
         if (current === null && base === "")
@@ -428,7 +521,7 @@ export function undoEntry(entry, clean) {
     if (current === null)
         return null;
     parseJson(entry.path, current);
-    const original = entry.backup ? readText(entry.backup) : null;
+    const original = entry.backup ? readText(entry.backup, true) : null;
     const base = editJson(current, entry.keyPath, undefined, original === null ? (entry.created ? {} : parseJson(entry.path, current)) : parseJson(entry.backup, original));
     if (entry.created && Object.keys(parseJson(entry.path, base)).length === 0 && !isSymlink(entry.path))
         removeFile(entry.path);

package/dist/helpers.d.ts

@@ -0,0 +1,15 @@
+import { type HelperServer } from "./constants.js";
+/**
+ * The stdio helpers the client roles call, shipped in `helpers/` (verbatim copies of the repo's
+ * scripts/*-mcp.mjs, see scripts/sync-assets.mjs). Agents start them as `npx -y robisie@<version> mcp <name>`.
+ */
+export declare const HELPER_TOOLS: Record<HelperServer, readonly string[]>;
+export declare function isHelperServer(value: string): value is HelperServer;
+export declare function helperPath(name: HelperServer): string;
+/** `robisie mcp <name>`: run the helper with this process's stdio (the agent talks MCP over it). */
+export declare function runHelper(name: HelperServer): Promise<number>;
+/**
+ * Start the helper, do the MCP handshake and list its tools — the proof that the helper actually runs here
+ * (its dependencies resolve, Node is new enough). Returns the tool names.
+ */
+export declare function probeHelper(name: HelperServer, env: Readonly<Record<string, string | undefined>>, cwd: string): Promise<string[]>;

package/dist/helpers.js

@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { HELPER_SERVERS, PACKAGE_NAME, PACKAGE_VERSION } from "./constants.js";
-import { RobisieError, errorMessage } from "./context.js";
+import { RobisieError } from "./context.js";
 /**
  * The stdio helpers the client roles call, shipped in `helpers/` (verbatim copies of the repo's
  * scripts/*-mcp.mjs, see scripts/sync-assets.mjs). Agents start them as `npx -y robisie@<version> mcp <name>`.
@@ -23,73 +23,290 @@ export function helperPath(name) {
 export function runHelper(name) {
     const path = helperPath(name);
     if (!existsSync(path)) {
-        return Promise.reject(new RobisieError(`Brak pomocnika ${name} w paczce.`, "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`."));
+        return Promise.reject(new RobisieError(`Brak pomocnika ${name} w paczce.`, "W katalogu projektu wykonaj `npm uninstall robisie`, potem `npm i robisie@<wersja-zgodna-z-kontraktem-serwera>` (zastąp placeholder numerem zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`."));
     }
     return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [path], { stdio: "inherit" });
-        child.on("error", (error) => reject(new RobisieError(`Nie mogę uruchomić pomocnika ${name}: ${errorMessage(error)}`, "Sprawdź instalację Node.js (wymagany 20+).")));
-        child.on("exit", (code, signal) => resolve(code ?? (signal ? 1 : 0)));
+        const failure = (stage) => new RobisieError(`Nie mogę uruchomić lub zakończyć pomocnika ${name}: ${stage}.`, "Sprawdź instalację Node.js (wymagany 20+).");
+        const detached = process.platform === "darwin" || process.platform === "linux";
+        let child;
+        try {
+            child = spawn(process.execPath, [path], { stdio: detached ? ["pipe", "inherit", "inherit"] : "inherit", detached });
+        }
+        catch {
+            reject(failure("start"));
+            return;
+        }
+        const pid = child.pid;
+        const input = process.stdin;
+        const parentPid = process.ppid;
+        let parentTimer;
+        let settled = false;
+        let stopping = false;
+        let timer;
+        let resultCode = 1;
+        let resultError;
+        let escalateAt = 0;
+        let deadline = 0;
+        let escalated = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(parentTimer);
+            process.off("SIGHUP", onHup);
+            input.off("end", onEof);
+            input.off("close", onEof);
+            input.off("error", onStreamError);
+            if (detached && child.stdin)
+                input.unpipe(child.stdin);
+            process.off("SIGINT", onInt);
+            process.off("SIGTERM", onTerm);
+            child.off("exit", onExit);
+            // Keep the guarded error listener until close: error can race with exit/invalid PID.
+            if (error)
+                reject(error);
+            else
+                resolve(resultCode);
+        };
+        const signalGroup = (signal) => {
+            try {
+                process.kill(-pid, signal);
+                return true;
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    finish(failure("zakończenie"));
+                return false;
+            }
+        };
+        const check = () => {
+            if (settled)
+                return;
+            if (!signalGroup(0)) {
+                finish(resultError);
+                return;
+            }
+            if (Date.now() >= deadline) {
+                finish(failure("nie mogę potwierdzić zakończenia grupy w ciągu 2 s"));
+                return;
+            }
+            if (!escalated && Date.now() >= escalateAt) {
+                escalated = true;
+                if (!signalGroup("SIGKILL")) {
+                    finish(resultError);
+                    return;
+                }
+            }
+            timer = setTimeout(check, 25);
+        };
+        const stop = (signal, code, error) => {
+            if (settled)
+                return;
+            resultError ??= error;
+            if (stopping)
+                return;
+            stopping = true;
+            resultCode = code;
+            escalateAt = Date.now() + 500;
+            deadline = Date.now() + 2000;
+            if (!signalGroup(signal)) {
+                finish(resultError);
+                return;
+            }
+            check();
+        };
+        const onInt = () => stop("SIGINT", 130);
+        const onTerm = () => stop("SIGTERM", 143);
+        const onHup = () => stop("SIGHUP", 129);
+        const onEof = () => stop("SIGTERM", 143);
+        const onStreamError = () => stop("SIGTERM", 1, failure("strumień"));
+        const watchParent = () => {
+            if (settled || stopping)
+                return;
+            if (process.ppid !== parentPid)
+                onEof();
+            else
+                parentTimer = setTimeout(watchParent, 250);
+        };
+        const onExit = (code, signal) => {
+            if (settled || stopping)
+                return;
+            resultCode = code ?? (signal ? 1 : 0);
+            if (!detached || !signalGroup(0))
+                finish();
+            else
+                stop("SIGTERM", resultCode);
+        };
+        const onError = () => {
+            if (settled)
+                return;
+            if (detached && Number.isInteger(pid) && pid > 0)
+                stop("SIGTERM", 1, failure("start"));
+            else
+                finish(failure("start"));
+        };
+        child.on("error", onError);
+        child.once("close", () => {
+            child.off("error", onError);
+            child.stdin?.off("error", onStreamError);
+        });
+        child.on("exit", onExit);
+        if (!Number.isInteger(pid) || pid <= 0) {
+            finish(failure("start (PID)"));
+            return;
+        }
+        if (detached) {
+            process.on("SIGINT", onInt);
+            process.on("SIGTERM", onTerm);
+            process.on("SIGHUP", onHup);
+            // The agent may close npx rather than this CLI. Own the input pipe so EOF
+            // interrupts active work even when npm does not forward process signals.
+            input.on("end", onEof);
+            input.on("close", onEof);
+            input.on("error", onStreamError);
+            child.stdin?.on("error", onStreamError);
+            try {
+                if (!child.stdin)
+                    throw new Error("Missing helper stdin");
+                input.pipe(child.stdin, { end: false });
+                if (input.readableEnded || input.destroyed)
+                    onEof();
+                watchParent();
+            }
+            catch {
+                onStreamError();
+            }
+        }
     });
 }
 const PROBE_TIMEOUT_MS = 20_000;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
 /**
  * Start the helper, do the MCP handshake and list its tools — the proof that the helper actually runs here
  * (its dependencies resolve, Node is new enough). Returns the tool names.
  */
 export function probeHelper(name, env, cwd) {
     return new Promise((resolve, reject) => {
-        // Cast: the repo's Next.js typings make NODE_ENV mandatory on ProcessEnv; the helper does not need it.
-        const child = spawn(process.execPath, [helperPath(name)], { cwd, env: { ...env }, stdio: ["pipe", "pipe", "pipe"] });
+        const failure = (stage) => new Error(`Pomocnik ${name}: ${stage}.`);
+        let child;
+        try {
+            // Cast: the repo's Next.js typings make NODE_ENV mandatory on ProcessEnv; the helper does not need it.
+            child = spawn(process.execPath, [helperPath(name)], { cwd, env: { ...env }, stdio: ["pipe", "pipe", "pipe"] });
+        }
+        catch {
+            reject(failure("start"));
+            return;
+        }
         let buffer = "";
         let settled = false;
+        let expectedId = 1;
         const finish = (error, tools) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
-            child.kill();
+            buffer = "";
+            try {
+                child.kill();
+            }
+            catch {
+                error ??= failure("zakończenie");
+            }
             if (error)
                 reject(error);
             else
                 resolve(tools ?? []);
         };
-        const timer = setTimeout(() => finish(new Error("brak odpowiedzi w ciągu 20 s")), PROBE_TIMEOUT_MS);
-        const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
-        child.on("error", (error) => finish(error));
-        child.on("exit", (code) => finish(new Error(`pomocnik zakończył się (kod ${code ?? "?"}) przed odpowiedzią`)));
-        child.stdin.on("error", () => undefined);
-        child.stdout.on("data", (chunk) => {
-            buffer += chunk.toString("utf8");
-            let newline = buffer.indexOf("\n");
-            while (newline !== -1) {
-                const line = buffer.slice(0, newline).trim();
-                buffer = buffer.slice(newline + 1);
-                newline = buffer.indexOf("\n");
-                if (!line)
-                    continue;
-                let message;
-                try {
-                    message = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                if (message.error)
-                    return finish(new Error(message.error.message ?? "błąd MCP"));
-                if (message.id === 1) {
-                    send({ jsonrpc: "2.0", method: "notifications/initialized" });
-                    send({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
-                }
-                else if (message.id === 2) {
-                    return finish(null, (message.result?.tools ?? []).map((tool) => String(tool.name)));
-                }
+        const timer = setTimeout(() => finish(new Error(`Pomocnik ${name}: zakończenie — brak odpowiedzi w ciągu 20 s`)), PROBE_TIMEOUT_MS);
+        const send = (message) => {
+            if (settled)
+                return;
+            try {
+                child.stdin.write(`${JSON.stringify(message)}\n`);
             }
-        });
-        send({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "initialize",
-            params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: `${PACKAGE_NAME}-doctor`, version: PACKAGE_VERSION } },
-        });
+            catch {
+                finish(failure("strumień"));
+            }
+        };
+        child.on("error", () => finish(failure("start")));
+        child.on("exit", (code) => finish(new Error(`Pomocnik ${name}: zakończenie (kod ${typeof code === "number" ? code : "?"}) przed odpowiedzią`)));
+        try {
+            child.stdin.on("error", () => finish(failure("strumień")));
+            child.stdout.on("error", () => finish(failure("strumień")));
+            child.stderr.on("error", () => finish(failure("strumień")));
+            child.stderr.resume(); // Discard diagnostics without retaining or publishing their contents.
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                if (settled)
+                    return;
+                buffer += chunk;
+                let newline = buffer.indexOf("\n");
+                while (newline !== -1) {
+                    const line = buffer.slice(0, newline).trim();
+                    buffer = buffer.slice(newline + 1);
+                    newline = buffer.indexOf("\n");
+                    if (!line)
+                        continue;
+                    let message;
+                    try {
+                        message = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!isRecord(message)) {
+                        return finish(failure("protokół"));
+                    }
+                    if (!("id" in message) || message.id !== expectedId)
+                        continue;
+                    if (message.jsonrpc !== "2.0" || ("result" in message) === ("error" in message)) {
+                        return finish(failure("protokół"));
+                    }
+                    if ("error" in message) {
+                        return finish(failure("protokół"));
+                    }
+                    if (message.id === 1) {
+                        const result = message.result;
+                        if (!isRecord(result) || !isRecord(result.capabilities) || !isRecord(result.serverInfo)
+                            || !nonEmptyString(result.protocolVersion) || !nonEmptyString(result.serverInfo.name)) {
+                            return finish(failure("protokół"));
+                        }
+                        expectedId = 2;
+                        send({ jsonrpc: "2.0", method: "notifications/initialized" });
+                        send({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
+                    }
+                    else if (message.id === 2) {
+                        const result = "result" in message ? message.result : undefined;
+                        if (!result || typeof result !== "object" || !("tools" in result) || !Array.isArray(result.tools)) {
+                            return finish(failure("protokół"));
+                        }
+                        const tools = result.tools;
+                        const names = [];
+                        for (const tool of tools) {
+                            if (!tool || typeof tool !== "object" || !("name" in tool) || typeof tool.name !== "string") {
+                                return finish(failure("protokół"));
+                            }
+                            names.push(tool.name);
+                        }
+                        return finish(null, names);
+                    }
+                }
+            });
+            send({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "initialize",
+                params: { protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: `${PACKAGE_NAME}-doctor`, version: PACKAGE_VERSION } },
+            });
+        }
+        catch {
+            finish(failure("strumień"));
+        }
     });
 }

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

@@ -0,0 +1,10 @@
+export declare const ISO_ZONE_FORMAT = "YYYY-MM-DDTHH:mm[:ss[.SSS]]Z or \u00B1HH:mm";
+export declare const ISO_ZONE_EXAMPLE = "2026-10-05T12:00:00+02:00";
+export declare function parseMachineDate(value: unknown): number | null;
+export interface MachineFieldProblem {
+    path: string;
+    receivedType: string;
+    expectedFormat: string;
+    example: string;
+}
+export declare function machineFieldProblem(details: Record<string, unknown> | null | undefined, projectId?: string, expectationProject?: string): MachineFieldProblem | null;

package/dist/intent-rules/admission.js

@@ -0,0 +1,35 @@
+// Port src/lib/planner/admission.ts z robisie-app (kopia: docs/zrodla/kompilator/admission.ts) — czysta granica pól maszynowych.
+// Jedyna zmiana: projekt oczekiwań (EXPECTATION_PROJECT) nie jest wbity w kod, tylko podawany z robisie.config.json (expectationProject).
+export const ISO_ZONE_FORMAT = 'YYYY-MM-DDTHH:mm[:ss[.SSS]]Z or ±HH:mm';
+export const ISO_ZONE_EXAMPLE = '2026-10-05T12:00:00+02:00';
+export function parseMachineDate(value) {
+    if (typeof value !== 'string')
+        return null;
+    const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?(Z|[+-](\d{2}):(\d{2}))$/.exec(value);
+    if (!m)
+        return null;
+    const [year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0] = m.slice(1, 7).map(v => Number(v ?? 0));
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    if (month < 1 || month > 12 || day < 1 || day > (days[month - 1] ?? 0)
+        || hour > 23 || minute > 59 || second > 59 || Number(m[9] ?? 0) > 23 || Number(m[10] ?? 0) > 59)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function machineFieldProblem(details, projectId, expectationProject) {
+    const problem = (path, value, object = false) => ({ path,
+        receivedType: value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value,
+        expectedFormat: object ? 'non-null, non-array object' : ISO_ZONE_FORMAT,
+        example: object ? '{"start_condition":"2026-10-05T12:00:00+02:00"}' : ISO_ZONE_EXAMPLE });
+    if (details && Object.hasOwn(details, 'admission')) {
+        const admission = details.admission;
+        if (admission === null || typeof admission !== 'object' || Array.isArray(admission))
+            return problem('details.admission', admission, true);
+        const record = admission;
+        if (Object.hasOwn(record, 'start_condition') && parseMachineDate(record.start_condition) === null)
+            return problem('details.admission.start_condition', record.start_condition);
+    }
+    return details && expectationProject !== undefined && projectId === expectationProject && Object.hasOwn(details, 'termin') && parseMachineDate(details.termin) === null
+        ? problem('details.termin', details.termin) : null;
+}