robisie 0.6.12 → 0.6.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +17 -0
- package/README.md +3 -3
- package/dist/cli.js +5 -2
- package/dist/commands.d.ts +2 -1
- package/dist/commands.js +109 -32
- package/dist/constants.d.ts +1 -1
- package/dist/constants.js +1 -1
- package/dist/engine/build-id.json +1 -1
- package/dist/engine/bundle-report.json +1 -1
- package/dist/engine/tick.cjs +1 -1
- package/dist/installation-update.d.ts +1 -0
- package/dist/installation-update.js +25 -2
- package/dist/roles.d.ts +1 -1
- package/docs/README.en.md +6 -6
- package/docs/README.md +6 -6
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,22 @@
|
|
|
1
1
|
# Historia zmian klienta / Client changelog
|
|
2
2
|
|
|
3
|
+
## [0.6.14](https://github.com/chuppa12/robisie-app/compare/client-v0.6.13...client-v0.6.14) (2026-11-19)
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
### Factory Cards
|
|
7
|
+
|
|
8
|
+
* Aktualizacja klienta w kontenerze bez systemd jako init (z binarką systemctl, z włączoną zgodą lub bez niej) przechodzi jednorazowo i kończy się kodem 0; host z systemd i zepsutą sesją nadal odmawia — jedna wersja dla wszystkich ([765232b](https://github.com/chuppa12/robisie-app/commit/765232bcf909796a60f26eb0a116c3f01adf4981))
|
|
9
|
+
|
|
10
|
+
## [0.6.13](https://github.com/chuppa12/robisie-app/compare/client-v0.6.12...client-v0.6.13) (2026-11-19)
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
### Factory Cards
|
|
14
|
+
|
|
15
|
+
* praca workera task-mwnk740j-y29cyi (auto-commit) ([2f9eba1](https://github.com/chuppa12/robisie-app/commit/2f9eba1df850bea2cfeae0742290484da17ea893))
|
|
16
|
+
* praca workera task-mwnsh6u1-hwh2qr (auto-commit) ([8ee74d0](https://github.com/chuppa12/robisie-app/commit/8ee74d052c7d0a7dde125a030ba1bbe061059a0a))
|
|
17
|
+
* praca workera task-mwntg8mp-h6l8gn (auto-commit) ([f594b9e](https://github.com/chuppa12/robisie-app/commit/f594b9e9446fb9fbf3238c29c14b2c703dfcfb65))
|
|
18
|
+
* praca workera task-mwnw845v-joe4i7 (auto-commit) ([3b06b2f](https://github.com/chuppa12/robisie-app/commit/3b06b2f2aca2cb3df9087b0727bae3b8cbdc47fc))
|
|
19
|
+
|
|
3
20
|
## [0.6.12](https://github.com/chuppa12/robisie-app/compare/client-v0.6.11...client-v0.6.12) (2026-11-19)
|
|
4
21
|
|
|
5
22
|
|
package/README.md
CHANGED
|
@@ -4,7 +4,7 @@ W katalogu projektu z konfiguracją silnika uruchom `npx robisie init`, potem `n
|
|
|
4
4
|
|
|
5
5
|
Przewodniki: [PL — konto → odbiór → odinstalowanie](docs/README.md) · [EN — account → acceptance → uninstall](docs/README.en.md). Przygotuj Node.js 24+ (wydanie użyte przy sprawdzeniach: 24.3.0), npm, program jednego dostawcy AI oraz pusty katalog; silnik w paczce (`dist/engine/tick.cjs`) dla klienta wymaga systemu Linux lub macOS. Jawny host Robisie (`mode: "host"`, `pr|delivered`) obsługuje także macOS; konfigurację i granice opisuje ENGINE-CONFIG. Nie potrzebujesz strony ani własnego pliku `package.json` — utworzy go poniższy krok Node.js przed instalacją. Zacznij od konta i projektu w panelu. Projekt w panelu i katalog na dysku to osobne rzeczy; CEO wymaga dokładnie jednego projektu z `list_projects`.
|
|
6
6
|
|
|
7
|
-
Konto i klucz są potrzebne do init i pracy ról. `npx robisie doctor --engine-config ./robisie.config.json` przy jawnym `engine.mode:host` sprawdza offline strukturę konfiguracji i wejścia instalacji lokalnej, bez kontroli CLI. Przy `engine.mode:client` albo braku pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza obecność CLI oraz logowanie tylko wybranych dostawców: `codex login status` dla Codexa i `grok
|
|
7
|
+
Konto i klucz są potrzebne do init i pracy ról. `npx robisie doctor --engine-config ./robisie.config.json` przy jawnym `engine.mode:host` sprawdza offline strukturę konfiguracji i wejścia instalacji lokalnej, bez kontroli CLI. Przy `engine.mode:client` albo braku pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza obecność CLI oraz logowanie tylko wybranych dostawców: `codex login status` dla Codexa i `grok -p "Odpowiedz jednym słowem: OK"` dla Groka, a `claude auth status` przy `reviewer-client.provider: claude` lub `receiver-client.provider: claude`. Brak programu nie pozwala sprawdzić logowania. Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Przy lokalnej polityce zarządzanej doctor pomija sondę i zgłasza brak potwierdzenia logowania. Potwierdza logowanie po udanej odpowiedzi `OK`. Doctor z `--engine-config` nie wykonuje komend silnika i nie potwierdza UUID projektu, repo ani modeli. Lokalne przewodniki są w `node_modules/robisie/docs/`.
|
|
8
8
|
|
|
9
9
|
Zamiast przepisywać klucze możesz uruchomić `npx robisie login`: polecenie wypisuje kod i link, Ty albo Twój agent zatwierdzacie parę kluczy A i B w przeglądarce zalogowanej do robisie.app, a klucze trafiają prosto do plików instalacji — w wersji dla testerów agent i właściciel na tym komputerze to jedna strefa zaufania (agent ma technicznie dostęp także do klucza B).
|
|
10
10
|
|
|
@@ -137,7 +137,7 @@ Po Connect, init i wczytaniu klucza według bloku powyżej uruchom `npx robisie
|
|
|
137
137
|
|
|
138
138
|
- **0 projektów, exit 1:** `CEO wymaga dokładnie 1 projektu (projektów: 0).` Następny krok: `Sprawdź gotowość projektu na https://robisie.app/dashboard/plugins/planer.` Wróć do przygotowania projektu opisanego przed init.
|
|
139
139
|
- **Więcej niż 1 projekt, exit 1** (np. `CEO wymaga dokładnie 1 projektu (projektów: 2).`): Uporządkuj widoczność projektów w `list_projects` do 1; sam wybór projektu w panelu nie zmienia wyniku `list_projects`. Człowiek sam decyduje, który projekt zachować aktywny; przy pozostałych na liście wybiera „Archiwizuj”. „Archiwum” → „Przywróć” cofa archiwizację. Nie usuwaj projektów. Kliknięcie projektu nie zawęża wyniku `list_projects`.
|
|
140
|
-
- **1 projekt:** oczekuj dokładnie `✓ Połączenie działa: klucz otwiera tablicę (projektów: 1).` oraz końcowego `Powyższe kontrole przeszły. Uruchom swojego agenta i poproś o rolę robisie CEO.` i exit 0.
|
|
140
|
+
- **1 projekt:** oczekuj dokładnie `✓ Połączenie działa: klucz otwiera tablicę (projektów: 1).` oraz końcowego `Powyższe kontrole przeszły. Uruchom swojego agenta i poproś o rolę robisie CEO.` i exit 0. Bez rejestru ról klienta linia `Gotowość wykonawców Codex–Grok:` mówi osobno, czy gotowość wykonawców jest `sprawdzona`, `niegotowa` czy `NIE SPRAWDZONO`. Zwykły doctor sprawdza tylko dostawców wybranych dla Workera, recenzenta i odbiorcy w konfiguracji klienta. Brak wpisu odbiorcy oznacza Groka. Dla Groka używa tej samej sondy (`grok -p "Odpowiedz jednym słowem: OK"`). Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Potwierdza logowanie po udanej odpowiedzi `OK`.
|
|
141
141
|
|
|
142
142
|
Po zmianie ponów `npx robisie doctor`. Rozwiąż też inne błędy doctor: sam licznik 1 nie wystarcza bez końcowego komunikatu sukcesu i exit 0.
|
|
143
143
|
|
|
@@ -231,7 +231,7 @@ Zapisz konfigurację projektu i osobny rejestr wykonania w `robisie.config.json`
|
|
|
231
231
|
|
|
232
232
|
Uruchom `npx robisie doctor --engine-config ./robisie.config.json` (także `--engine-config=./robisie.config.json`). Ścieżka pliku jest względem bieżącego katalogu, a `repo` i `stateDir` względem pliku konfiguracji. Role projektu `coordinator/owner/planner/advisor` zachowują domyślne nazwy; opcjonalne pole `roles` służy ich nazwom i odmianie, osobno od `roleRegistry`.
|
|
233
233
|
|
|
234
|
-
Kod 0 oznacza poprawną strukturę konfiguracji i cztery wymagane kompletne przypisania wykonania i opcjonalnego odbiorcę; raport pokazuje rolę → imię / dostawcę / model / wysiłek. Kod 1 wskazuje plik, błędne pole (jeśli dotyczy) i następny krok. Jawny `engine.mode:host` sprawdza strukturę i wejścia offline, bez kontroli CLI. `engine.mode:client` albo brak pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza obecność CLI oraz logowanie tylko wybranych dostawców: `codex login status` dla Codexa i `grok
|
|
234
|
+
Kod 0 oznacza poprawną strukturę konfiguracji i cztery wymagane kompletne przypisania wykonania i opcjonalnego odbiorcę; raport pokazuje rolę → imię / dostawcę / model / wysiłek. Kod 1 wskazuje plik, błędne pole (jeśli dotyczy) i następny krok. Jawny `engine.mode:host` sprawdza strukturę i wejścia offline, bez kontroli CLI. `engine.mode:client` albo brak pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza obecność CLI oraz logowanie tylko wybranych dostawców: `codex login status` dla Codexa i `grok -p "Odpowiedz jednym słowem: OK"` dla Groka, a `claude auth status` przy `reviewer-client.provider: claude` lub `receiver-client.provider: claude`. Brak programu nie pozwala sprawdzić logowania. Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Potwierdza logowanie po udanej odpowiedzi `OK`. Doctor z `--engine-config` nie wykonuje komend silnika ani nie potwierdza UUID projektu, repo ani modeli. Raport nadal stwierdza: „sprawdzono konfigurację; nie sprawdzono uruchomienia dostawców”. Kontrole instalacji i klucza robisie wykonuje zwykły `doctor`. Tryb nie wymaga klucza.
|
|
235
235
|
|
|
236
236
|
Silnik paczki — `dist/engine/tick.cjs` — jest odrębny od instalatora: `init`/`doctor`/`uninstall` go nie uruchamiają. Uruchamia go `npx robisie factory run --engine-config ./robisie.config.json` (flaga `--once` wykonuje jeden takt) na Linuxie lub macOS dla klienta (`local`) oraz jawnego hosta Robisie (`mode: "host"`, `pr|delivered`), z Node.js 24+; starszy Node, np. 22, otrzymuje odmowę przed `init`, `doctor` i `factory run`, a pozostałe systemy otrzymują kod 2 i komunikat. Pełny opis pól konfiguracji: `node_modules/robisie/docs/ENGINE-CONFIG.md`. Każdy niezerowy wynik taktu zatrzymuje nadzorcę („Fabryka zatrzymana: …”) z jedną linią diagnozy na stderr; kod 2 to eskalacja (np. brak klucza B po receiver PASS, odmowa testera, STOP odbioru) wymagająca rozstrzygnięcia przed ponowieniem, a kod 78 wskazuje konfigurację do poprawy.
|
|
237
237
|
|
package/dist/cli.js
CHANGED
|
@@ -58,8 +58,11 @@ Opcje doctor:
|
|
|
58
58
|
Jawny engine.mode:host: offline sprawdza strukturę konfiguracji i wejścia, bez kontroli CLI.
|
|
59
59
|
engine.mode:client albo brak pola engine.mode: obecność CLI i logowanie; sonda po walidacji wejść, tylko przy dostępnym programie.
|
|
60
60
|
Przykład: npx robisie doctor --engine-config ./robisie.config.json
|
|
61
|
-
Klient: codex login status i grok
|
|
62
|
-
|
|
61
|
+
Klient: codex login status i grok -p "Odpowiedz jednym słowem: OK". Dodatkowo claude auth status przy reviewer-client.provider: claude lub receiver-client.provider: claude. Brak programu nie pozwala sprawdzić logowania.
|
|
62
|
+
Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Potwierdza logowanie po udanej odpowiedzi OK.
|
|
63
|
+
Sonda działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Przy lokalnej polityce zarządzanej pomija sondę i zgłasza brak potwierdzenia logowania.
|
|
64
|
+
Zwykły doctor używa tej samej sondy i sprawdza tylko dostawców wybranych w konfiguracji klienta.
|
|
65
|
+
Z --engine-config nie wykonuje komend silnika i nie sprawdza UUID projektu, repo ani dostępności modeli. Bez klucza.
|
|
63
66
|
Role wykonania w tym pliku są osobne od mapy ceo/builder/quality ustawianej przez init.
|
|
64
67
|
Przewodniki i przykłady: node_modules/robisie/docs/README.md oraz README.en.md w tym samym katalogu.
|
|
65
68
|
|
package/dist/commands.d.ts
CHANGED
|
@@ -16,11 +16,12 @@ export declare function initRecoveryStep(ctx: Ctx, preferred?: AgentId): string;
|
|
|
16
16
|
export declare function recoveryStep(ctx: Ctx, step: string): string;
|
|
17
17
|
export declare function init(ctx: Ctx, options: InitOptions): Promise<void>;
|
|
18
18
|
export declare const DOCTOR_SUCCESS = "Powy\u017Csze kontrole przesz\u0142y. Uruchom swojego agenta i popro\u015B o rol\u0119 robisie CEO.";
|
|
19
|
-
/**
|
|
19
|
+
/** Capture only the output needed by the checks. Provider output is never printed. */
|
|
20
20
|
export declare const loginIo: {
|
|
21
21
|
run(binary: string, args: readonly string[], env: NodeJS.ProcessEnv, cwd: string): {
|
|
22
22
|
status: number | null;
|
|
23
23
|
stdout?: string | null;
|
|
24
|
+
stderr?: string | null;
|
|
24
25
|
};
|
|
25
26
|
};
|
|
26
27
|
/** Uses the registry already read by doctorEngineConfig, without reopening configuration. */
|
package/dist/commands.js
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { spawnSync } from "node:child_process";
|
|
2
|
-
import { accessSync, constants, lstatSync, readdirSync, rmdirSync, rmSync, statSync } from "node:fs";
|
|
3
|
-
import {
|
|
2
|
+
import { accessSync, constants, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmdirSync, rmSync, statSync } from "node:fs";
|
|
3
|
+
import { tmpdir } from "node:os";
|
|
4
|
+
import { delimiter, dirname, join, resolve } from "node:path";
|
|
4
5
|
import { parse } from "smol-toml";
|
|
5
6
|
import { AGENT_IDS, AGENT_LABELS, SHELL_EXPORT, agentPaths, agentOnPath, detectAgents, planAgent, removeCodexTables, shellProfile } from "./agents.js";
|
|
6
7
|
import { HELPER_SERVERS, KEY_ENV, KEY_PATTERN, PACKAGE_NAME, PACKAGE_VERSION } from "./constants.js";
|
|
@@ -8,13 +9,14 @@ import { RobisieError, errorMessage } from "./context.js";
|
|
|
8
9
|
import { assertCodexEnvironment } from "./codex-env.js";
|
|
9
10
|
import { loginFiles } from "./device-login.js";
|
|
10
11
|
import { reportDoctorDisk } from "./disk-guard.js";
|
|
12
|
+
import { CONFIG_FILE } from "./engine-config.js";
|
|
11
13
|
import { applyOp, assertCodexChange, checkRecovery, preserveFileStep, capture, entryPresent, fingerprint, prepareBlock, refusePrivateSymlink, renderBlock, restore, undoEntry } from "./fsops.js";
|
|
12
14
|
import { HELPER_TOOLS, probeHelper } from "./helpers.js";
|
|
13
15
|
import { clientPaths, ensurePrivateDir, loginFields, readKey, readManifest, writeKey, writeManifest, roleProviders, ROLE_IDS, ROLE_STEP } from "./manifest.js";
|
|
14
16
|
import { assertCompatible, checkConnection, fetchContractVersion } from "./mcp.js";
|
|
15
17
|
import { loadRoles, MANAGED_LINE, rolesDir } from "./roles.js";
|
|
16
18
|
import { checkInputs, createInputs, INPUTS_OK, preflightInputs, selectInputDirectory } from "./engine-inputs.js";
|
|
17
|
-
import { validateClientRoles } from "./role-registry.js";
|
|
19
|
+
import { parseRoleRegistry, validateClientRoles } from "./role-registry.js";
|
|
18
20
|
import { PlanerClient } from "./planer-client.js";
|
|
19
21
|
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ą).";
|
|
20
22
|
const KEY_FORMAT_STEP = `Skopiuj klucz jeszcze raz z https://robisie.app/dashboard/connect; ustaw poprawny ROBISIE_KEY w środowisku lokalnego init (poza rozmową i historią poleceń) albo 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\`.`;
|
|
@@ -260,12 +262,47 @@ function installedVersions(op, text) {
|
|
|
260
262
|
}
|
|
261
263
|
// ── doctor ───────────────────────────────────────────────────────────────────
|
|
262
264
|
export const DOCTOR_SUCCESS = "Powyższe kontrole przeszły. Uruchom swojego agenta i poproś o rolę robisie CEO.";
|
|
263
|
-
/**
|
|
265
|
+
/** Capture only the output needed by the checks. Provider output is never printed. */
|
|
264
266
|
export const loginIo = {
|
|
265
267
|
run(binary, args, env, cwd) {
|
|
266
|
-
const
|
|
267
|
-
const
|
|
268
|
-
|
|
268
|
+
const prompt = args[0] === "-p";
|
|
269
|
+
const captureStdout = prompt || args[0] === "--version";
|
|
270
|
+
let probeDir;
|
|
271
|
+
try {
|
|
272
|
+
if (prompt) {
|
|
273
|
+
if (!env.HOME)
|
|
274
|
+
return { status: null };
|
|
275
|
+
const profile = resolve(cwd, env.GROK_HOME || join(env.HOME, ".grok"));
|
|
276
|
+
// Profile isolation skips user policy but leaves system policy active.
|
|
277
|
+
if (["managed_config.toml", "requirements.toml"].some(file => lstatSync(join(profile, file), { throwIfNoEntry: false }) ||
|
|
278
|
+
lstatSync(join("/etc/grok", file), { throwIfNoEntry: false })))
|
|
279
|
+
return { status: null };
|
|
280
|
+
// Grok discovers project instructions and hooks from cwd, even in headless mode.
|
|
281
|
+
const base = realpathSync(tmpdir());
|
|
282
|
+
for (let parent = base;; parent = dirname(parent)) {
|
|
283
|
+
if (lstatSync(join(parent, ".git"), { throwIfNoEntry: false }))
|
|
284
|
+
return { status: null };
|
|
285
|
+
if (dirname(parent) === parent)
|
|
286
|
+
break;
|
|
287
|
+
}
|
|
288
|
+
probeDir = mkdtempSync(join(base, "robisie-doctor-grok-"));
|
|
289
|
+
const home = join(probeDir, "home");
|
|
290
|
+
mkdirSync(home, { mode: 0o700 });
|
|
291
|
+
// Keep session credentials in their original store. Grok opens it itself.
|
|
292
|
+
env = {
|
|
293
|
+
...env, HOME: home, GROK_HOME: join(home, ".grok"), CODEX_HOME: join(home, ".codex"),
|
|
294
|
+
XDG_CONFIG_HOME: join(home, ".config"), GROK_AUTH_PATH: join(profile, "auth.json"),
|
|
295
|
+
};
|
|
296
|
+
args = [...args, "--tools", "", "--deny", "*", "--deny", "MCPTool(*)", "--permission-mode", "dontAsk",
|
|
297
|
+
"--disable-web-search", "--verbatim", "--max-turns", "1"];
|
|
298
|
+
}
|
|
299
|
+
const result = spawnSync(binary, args, { cwd: probeDir ?? cwd, env, stdio: ["ignore", captureStdout ? "pipe" : "ignore", prompt ? "pipe" : "ignore"], encoding: "utf8", timeout: 20_000, killSignal: "SIGKILL", shell: false });
|
|
300
|
+
return { status: result.error ? null : result.status, ...(captureStdout ? { stdout: result.stdout } : {}), ...(prompt ? { stderr: result.stderr } : {}) };
|
|
301
|
+
}
|
|
302
|
+
finally {
|
|
303
|
+
if (probeDir)
|
|
304
|
+
rmSync(probeDir, { force: true, recursive: true });
|
|
305
|
+
}
|
|
269
306
|
},
|
|
270
307
|
};
|
|
271
308
|
// The engine's provider env (engine-context/review-job allowlists), never the robisie keys.
|
|
@@ -287,8 +324,7 @@ function findProgram(cwd, path, name) {
|
|
|
287
324
|
}
|
|
288
325
|
return null;
|
|
289
326
|
}
|
|
290
|
-
|
|
291
|
-
function pairReadiness(ctx, fail, registry) {
|
|
327
|
+
function pairEnvironment(ctx) {
|
|
292
328
|
const home = ctx.env.HOME || ctx.home;
|
|
293
329
|
const env = {};
|
|
294
330
|
for (const name of PAIR_ENV)
|
|
@@ -296,6 +332,11 @@ function pairReadiness(ctx, fail, registry) {
|
|
|
296
332
|
env[name] = ctx.env[name];
|
|
297
333
|
env.HOME = home;
|
|
298
334
|
const reviewEnv = { ...env, PATH: `${join(home, ".local/bin")}${delimiter}${env.PATH ?? ""}` };
|
|
335
|
+
return { home, env, reviewEnv };
|
|
336
|
+
}
|
|
337
|
+
/** Login of the selected execution processes; the legacy pair remains Codex–Grok. */
|
|
338
|
+
function pairReadiness(ctx, fail, registry) {
|
|
339
|
+
const { home, env, reviewEnv } = pairEnvironment(ctx);
|
|
299
340
|
const retry = "Potem ponów `npx robisie doctor`.";
|
|
300
341
|
let unchecked = false;
|
|
301
342
|
let failed = false;
|
|
@@ -316,19 +357,32 @@ function pairReadiness(ctx, fail, registry) {
|
|
|
316
357
|
fail(`Codex nie jest zalogowany w środowisku silnika (HOME=${home}).`, `Zaloguj Codex: \`codex login --device-auth\`. ${retry}`);
|
|
317
358
|
}
|
|
318
359
|
}
|
|
319
|
-
// Grok CLI has no login-status command; `grok models` lists models without a paid model call.
|
|
320
360
|
if (providers.has("grok")) {
|
|
321
361
|
const grok = findProgram(ctx.cwd, reviewEnv.PATH, "grok");
|
|
322
362
|
if (!grok) {
|
|
323
363
|
unchecked = true;
|
|
324
364
|
fail("Grok: brak programu grok w PATH — logowania NIE SPRAWDZONO.", "Zainstaluj Grok CLI i ponów doctor.");
|
|
325
365
|
}
|
|
326
|
-
else if (loginIo.run(grok, ["models"], reviewEnv, ctx.cwd).status === 0) {
|
|
327
|
-
ctx.out(`✓ Grok prawdopodobnie zalogowany (\`grok models\` działa; Grok CLI nie ma polecenia statusu logowania; HOME=${home}).`);
|
|
328
|
-
}
|
|
329
366
|
else {
|
|
330
|
-
|
|
331
|
-
|
|
367
|
+
let result = null;
|
|
368
|
+
try {
|
|
369
|
+
result = loginIo.run(grok, ["-p", "Odpowiedz jednym słowem: OK"], reviewEnv, ctx.cwd);
|
|
370
|
+
}
|
|
371
|
+
catch {
|
|
372
|
+
// A failed launch cannot confirm login. Do not expose provider diagnostics.
|
|
373
|
+
}
|
|
374
|
+
const denied = [result?.stdout, result?.stderr].some(output => typeof output === "string" && /not signed in/i.test(output));
|
|
375
|
+
if (denied) {
|
|
376
|
+
failed = true;
|
|
377
|
+
fail(`Grok nie jest zalogowany w środowisku silnika (HOME=${home}).`, `Zaloguj Grok: \`grok login --device-code\`. ${retry}`);
|
|
378
|
+
}
|
|
379
|
+
else if (result?.status === 0 && typeof result.stdout === "string" && result.stdout.trim() === "OK") {
|
|
380
|
+
ctx.out(`✓ Grok zalogowany (sonda zwróciła OK, HOME=${home}).`);
|
|
381
|
+
}
|
|
382
|
+
else {
|
|
383
|
+
failed = true;
|
|
384
|
+
fail(`Grok: nie potwierdzono zalogowania w środowisku silnika (HOME=${home}).`, `Sprawdź połączenie z siecią i działanie Grok CLI. Jeśli potrzeba, zaloguj Grok: \`grok login --device-code\`. ${retry}`);
|
|
385
|
+
}
|
|
332
386
|
}
|
|
333
387
|
}
|
|
334
388
|
if (providers.has("claude")) {
|
|
@@ -345,7 +399,7 @@ function pairReadiness(ctx, fail, registry) {
|
|
|
345
399
|
fail("Claude: nie potwierdzono zalogowania w środowisku silnika.", "Zaloguj Claude: `claude auth login`. " + retry);
|
|
346
400
|
}
|
|
347
401
|
}
|
|
348
|
-
return failed ? "niegotowa" : unchecked ? "NIE SPRAWDZONO" :
|
|
402
|
+
return failed ? "niegotowa" : unchecked ? "NIE SPRAWDZONO" : "sprawdzona";
|
|
349
403
|
}
|
|
350
404
|
/** Uses the registry already read by doctorEngineConfig, without reopening configuration. */
|
|
351
405
|
export function doctorClientPair(ctx, registry) {
|
|
@@ -353,22 +407,19 @@ export function doctorClientPair(ctx, registry) {
|
|
|
353
407
|
if (registry["worker-client"].provider === "grok" && !findProgram(ctx.cwd, ctx.env.PATH ?? "", "bwrap"))
|
|
354
408
|
throw new RobisieError("Worker Grok wymaga bubblewrap (bwrap) do ochrony profilu na Linuksie.", "Zainstaluj bubblewrap albo wybierz Codex.");
|
|
355
409
|
if (registry["worker-client"].provider === "grok") {
|
|
356
|
-
const
|
|
357
|
-
const
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
410
|
+
const { reviewEnv } = pairEnvironment(ctx);
|
|
411
|
+
const binary = findProgram(ctx.cwd, reviewEnv.PATH, "grok");
|
|
412
|
+
// An absent binary is reported by pairReadiness with installation advice.
|
|
413
|
+
if (binary) {
|
|
414
|
+
let version = null;
|
|
415
|
+
try {
|
|
416
|
+
const result = loginIo.run(binary, ["--version"], reviewEnv, ctx.cwd);
|
|
417
|
+
version = result.status === 0 && typeof result.stdout === "string" ? result.stdout.trim().match(/^grok (\d+)\.(\d+)\.(\d+)(?:\s|$)/) : null;
|
|
418
|
+
}
|
|
419
|
+
catch { /* Unreadable version fails closed below. */ }
|
|
420
|
+
if (!version || !(Number(version[1]) > 1 || Number(version[1]) === 1 && (Number(version[2]) > 0 || Number(version[3]) >= 77)))
|
|
421
|
+
throw new RobisieError("Worker Grok wymaga Grok CLI 1.0.77 albo nowszego. Zaktualizuj Grok CLI: `grok update`.", "Zaktualizuj Grok CLI: `grok update`.");
|
|
368
422
|
}
|
|
369
|
-
catch { /* Missing or unreadable version fails closed below. */ }
|
|
370
|
-
if (!version || !(Number(version[1]) > 1 || Number(version[1]) === 1 && (Number(version[2]) > 0 || Number(version[3]) >= 77)))
|
|
371
|
-
throw new RobisieError("Worker Grok wymaga Grok CLI 1.0.77 albo nowszego. Zaktualizuj Grok CLI: `grok update`.", "Zaktualizuj Grok CLI: `grok update`.");
|
|
372
423
|
}
|
|
373
424
|
const reviewer = registry["reviewer-client"];
|
|
374
425
|
ctx.out(`Recenzent: ${reviewer.provider}/${reviewer.model}; niezależność: ${reviewer.requireIndependentProvider === false ? "częściowa: bez niezależnego sprawdzenia" : "wymagana"}.`);
|
|
@@ -380,6 +431,27 @@ export function doctorClientPair(ctx, registry) {
|
|
|
380
431
|
if (problems.length)
|
|
381
432
|
throw new RobisieError("Wykonawcy klienta niegotowi.", problems[0]);
|
|
382
433
|
}
|
|
434
|
+
function configuredClientRegistry(ctx) {
|
|
435
|
+
const selected = ctx.env.ROBISIE_ENGINE_CONFIG;
|
|
436
|
+
const path = resolve(ctx.cwd, selected?.trim() ? selected : CONFIG_FILE);
|
|
437
|
+
let raw;
|
|
438
|
+
try {
|
|
439
|
+
raw = JSON.parse(readFileSync(path, "utf8").replace(/^\uFEFF/, ""));
|
|
440
|
+
}
|
|
441
|
+
catch (error) {
|
|
442
|
+
if (!selected?.trim() && error.code === "ENOENT")
|
|
443
|
+
return null;
|
|
444
|
+
throw new RobisieError(`Nie mogę odczytać konfiguracji silnika: ${path}.`, "Sprawdź plik i jego uprawnienia, potem ponów `npx robisie doctor`.");
|
|
445
|
+
}
|
|
446
|
+
if (!raw || typeof raw !== "object" || !("engine" in raw) || !("roleRegistry" in raw))
|
|
447
|
+
return null;
|
|
448
|
+
const engine = raw.engine;
|
|
449
|
+
if (engine && typeof engine === "object" && "mode" in engine && engine.mode === "host")
|
|
450
|
+
return null;
|
|
451
|
+
const registry = parseRoleRegistry(raw, path);
|
|
452
|
+
validateClientRoles(registry["worker-client"], registry["reviewer-client"], registry["receiver-client"], ctx.platform);
|
|
453
|
+
return registry;
|
|
454
|
+
}
|
|
383
455
|
/** Returns the process exit code: 0 = all good, 1 = something needs one action. */
|
|
384
456
|
export async function doctor(ctx) {
|
|
385
457
|
let policyLine = "! Polityka enforced: NIE SPRAWDZONO — odczyt nieudany.";
|
|
@@ -401,12 +473,14 @@ export async function doctor(ctx) {
|
|
|
401
473
|
};
|
|
402
474
|
ctx.out(`Paczka ${PACKAGE_NAME} ${PACKAGE_VERSION}`);
|
|
403
475
|
const paths = clientPaths(agentPaths(ctx).clientDir);
|
|
476
|
+
let registry;
|
|
404
477
|
await guard(async () => {
|
|
405
478
|
const inputs = selectInputDirectory(ctx);
|
|
406
479
|
if (inputs) {
|
|
407
480
|
checkInputs(inputs.directory, inputs.configPath);
|
|
408
481
|
ctx.out(INPUTS_OK);
|
|
409
482
|
}
|
|
483
|
+
registry = configuredClientRegistry(ctx);
|
|
410
484
|
});
|
|
411
485
|
// Same 15 HOLD / 18 unblock thresholds as the packaged engine (engine-context disk()).
|
|
412
486
|
const disk = reportDoctorDisk(ctx.out, ctx.cwd);
|
|
@@ -593,7 +667,10 @@ export async function doctor(ctx) {
|
|
|
593
667
|
}
|
|
594
668
|
if (!envKey)
|
|
595
669
|
fail(`Zmienna ${KEY_ENV} nie jest ustawiona — role i agenci jej potrzebują.`, `Jeśli init zapisał profil zsh/bash, otwórz nowy terminal z tym samym XDG_CONFIG_HOME. Przy --no-shell/innej powłoce ustaw środowisko agenta bez ujawniania klucza; w powłoce POSIX: ${SHELL_EXPORT}`);
|
|
596
|
-
|
|
670
|
+
if (registry !== undefined) {
|
|
671
|
+
const label = registry ? "Gotowość wykonawców" : "Gotowość wykonawców Codex–Grok";
|
|
672
|
+
ctx.out(`${label}: ${pairReadiness(ctx, fail, registry)}.`);
|
|
673
|
+
}
|
|
597
674
|
if (problems.length === 0) {
|
|
598
675
|
ctx.out(DOCTOR_SUCCESS);
|
|
599
676
|
return 0;
|
package/dist/constants.d.ts
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/** Package identity and the server contract it speaks. */
|
|
2
2
|
export declare const PACKAGE_NAME = "robisie";
|
|
3
|
-
export declare const PACKAGE_VERSION = "0.6.
|
|
3
|
+
export declare const PACKAGE_VERSION = "0.6.14";
|
|
4
4
|
/**
|
|
5
5
|
* MAJOR of the agent-API contract this package understands.
|
|
6
6
|
* PARITY: src/lib/mcp/contract-version.ts (AGENT_API_CONTRACT_VERSION) on the server.
|
package/dist/constants.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/** Package identity and the server contract it speaks. */
|
|
2
2
|
export const PACKAGE_NAME = "robisie";
|
|
3
|
-
export const PACKAGE_VERSION = "0.6.
|
|
3
|
+
export const PACKAGE_VERSION = "0.6.14"; // x-release-please-version
|
|
4
4
|
/**
|
|
5
5
|
* MAJOR of the agent-API contract this package understands.
|
|
6
6
|
* PARITY: src/lib/mcp/contract-version.ts (AGENT_API_CONTRACT_VERSION) on the server.
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"schema":1,"sha":"
|
|
1
|
+
{"schema":1,"sha":"099c017febcfb191a7cf402d46bcafcfb001b257","dirty":false}
|
|
@@ -1725,6 +1725,6 @@
|
|
|
1725
1725
|
"status": 0,
|
|
1726
1726
|
"signal": null,
|
|
1727
1727
|
"stdout": "v24.3.0\n",
|
|
1728
|
-
"stderr": "(node:
|
|
1728
|
+
"stderr": "(node:24522) ExperimentalWarning: SQLite is an experimental feature and might change at any time\n(Use `node --trace-warnings ...` to show where the warning was created)\n"
|
|
1729
1729
|
}
|
|
1730
1730
|
}
|
package/dist/engine/tick.cjs
CHANGED
|
@@ -37652,7 +37652,7 @@ var init_constants = __esm({
|
|
|
37652
37652
|
"packages/client/src/constants.ts"() {
|
|
37653
37653
|
"use strict";
|
|
37654
37654
|
PACKAGE_NAME = "robisie";
|
|
37655
|
-
PACKAGE_VERSION = "0.6.
|
|
37655
|
+
PACKAGE_VERSION = "0.6.14";
|
|
37656
37656
|
SUPPORTED_CONTRACT_MAJOR = 1;
|
|
37657
37657
|
DEFAULT_ORIGIN = "https://robisie.app";
|
|
37658
37658
|
MCP_SERVER_NAME = "robisie";
|
|
@@ -6,6 +6,7 @@ export type UpdateBoard = Pick<PlanerClient, 'listTasks' | 'getTask' | 'updateTa
|
|
|
6
6
|
/** External effects only; no alternative update policy or hidden CLI flags. */
|
|
7
7
|
export interface UpdateRuntime {
|
|
8
8
|
fs: typeof fs;
|
|
9
|
+
systemdBooted(): boolean;
|
|
9
10
|
exec: (command: string, args: readonly string[], cwd: string, env: NodeJS.ProcessEnv) => {
|
|
10
11
|
status: number | null;
|
|
11
12
|
signal: string | null;
|
|
@@ -14,6 +14,9 @@ function refuse(message) {
|
|
|
14
14
|
throw new RobisieError(message, 'Sprawdź konfigurację i prywatny audyt w <stateDir>/update; usuń przyczynę przed kolejnym wywołaniem update.');
|
|
15
15
|
}
|
|
16
16
|
function code(error) { return error?.code; }
|
|
17
|
+
function probeExitedNonzero(outcome) {
|
|
18
|
+
return Number.isInteger(outcome.status) && outcome.status !== 0 && outcome.signal === null && outcome.errorCode === undefined;
|
|
19
|
+
}
|
|
17
20
|
function object(raw) { return raw !== null && typeof raw === 'object' && !Array.isArray(raw); }
|
|
18
21
|
function json(bytes) {
|
|
19
22
|
const raw = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes).replace(/^\uFEFF/, ''));
|
|
@@ -52,11 +55,21 @@ async function connectBoard(ctx) {
|
|
|
52
55
|
}
|
|
53
56
|
export async function runInstallationUpdate(ctx, options, overrides = {}) {
|
|
54
57
|
const runtime = {
|
|
55
|
-
fs,
|
|
58
|
+
fs,
|
|
59
|
+
systemdBooted() {
|
|
60
|
+
try {
|
|
61
|
+
this.fs.lstatSync('/run/systemd/system');
|
|
62
|
+
return true;
|
|
63
|
+
}
|
|
64
|
+
catch (error) {
|
|
65
|
+
return code(error) !== 'ENOENT';
|
|
66
|
+
}
|
|
67
|
+
},
|
|
68
|
+
exec: (command, args, cwd, env) => {
|
|
56
69
|
const result = spawnSync(command, args, { cwd, env, encoding: 'utf8', shell: false, timeout: 120_000, maxBuffer: 4 * 1024 * 1024 });
|
|
57
70
|
const errorCode = code(result.error);
|
|
58
71
|
return { status: result.status, signal: result.signal, stdout: result.stdout, stderr: result.stderr,
|
|
59
|
-
errorCode: typeof errorCode === 'string' ? errorCode : undefined };
|
|
72
|
+
errorCode: typeof errorCode === 'string' ? errorCode : result.error ? 'UNKNOWN' : undefined };
|
|
60
73
|
}, kill: process.kill, now: Date.now, sleep: ms => new Promise(done => setTimeout(done, ms)),
|
|
61
74
|
interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
|
|
62
75
|
ask: async (question) => {
|
|
@@ -264,6 +277,14 @@ export async function runInstallationUpdate(ctx, options, overrides = {}) {
|
|
|
264
277
|
const probeClient = () => {
|
|
265
278
|
const outcome = runtime.exec(manager, probeArgs, ctx.cwd, env);
|
|
266
279
|
oneShot = outcome.errorCode === 'ENOENT' && outcome.status === null && outcome.signal === null;
|
|
280
|
+
if (probeExitedNonzero(outcome)) {
|
|
281
|
+
try {
|
|
282
|
+
oneShot = runtime.systemdBooted() === false;
|
|
283
|
+
}
|
|
284
|
+
catch {
|
|
285
|
+
oneShot = false;
|
|
286
|
+
}
|
|
287
|
+
}
|
|
267
288
|
return outcome;
|
|
268
289
|
};
|
|
269
290
|
const clientProbe = linuxClient && !config.update?.enabled ? probeClient() : undefined;
|
|
@@ -282,6 +303,8 @@ export async function runInstallationUpdate(ctx, options, overrides = {}) {
|
|
|
282
303
|
}
|
|
283
304
|
managerProbed = true;
|
|
284
305
|
};
|
|
306
|
+
if (clientProbe && !oneShot && probeExitedNonzero(clientProbe))
|
|
307
|
+
probeManager();
|
|
285
308
|
if (!oneShot && !config.update?.enabled) {
|
|
286
309
|
if (!runtime.interactive || config.update?.enabled === false) {
|
|
287
310
|
ctx.out('Aktualizacja pominięta: brak włączonej zgody w konfiguracji.');
|
package/dist/roles.d.ts
CHANGED
|
@@ -17,7 +17,7 @@ export interface Role {
|
|
|
17
17
|
export declare function rolesDir(): string;
|
|
18
18
|
export declare function parseRole(file: Role["file"], text: string): Role;
|
|
19
19
|
export declare function loadRoles(dir?: string): Role[];
|
|
20
|
-
export declare const MANAGED_LINE = "<!-- robisie:managed 0.6.
|
|
20
|
+
export declare const MANAGED_LINE = "<!-- robisie:managed 0.6.14 \u2014 plik zarz\u0105dzany przez `npx robisie`; `npx robisie uninstall` go usunie -->";
|
|
21
21
|
export type AgentFlavor = "claude" | "codex" | "opencode";
|
|
22
22
|
/** How the operator starts the Builder for one card in its own session (the card id is not a secret). */
|
|
23
23
|
export declare function builderStartCommand(flavor: AgentFlavor, codexRolePath?: string): string;
|
package/docs/README.en.md
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
# robisie — from account to accepted card (package 0.6.
|
|
1
|
+
# robisie — from account to accepted card (package 0.6.14) <!-- x-release-please-version -->
|
|
2
2
|
|
|
3
3
|
In the project directory with its engine configuration, run `npx robisie init`, then `npx robisie doctor`: init prepares the project goal and tester protection list, and doctor checks both inputs.
|
|
4
4
|
|
|
@@ -7,7 +7,7 @@ Polski: [README.md](README.md).
|
|
|
7
7
|
<!-- sekcja: dostepnosc -->
|
|
8
8
|
## Availability
|
|
9
9
|
|
|
10
|
-
An account and key are needed for init and the roles. `npx robisie doctor --engine-config ./robisie.config.json` with explicit `engine.mode:host` checks structure and local installation inputs offline, without CLI checks. With `engine.mode:client` or a missing `engine.mode` field, after input validation and when the program is available, it also checks CLI presence and login only for selected providers: `codex login status` for Codex and `grok
|
|
10
|
+
An account and key are needed for init and the roles. `npx robisie doctor --engine-config ./robisie.config.json` with explicit `engine.mode:host` checks structure and local installation inputs offline, without CLI checks. With `engine.mode:client` or a missing `engine.mode` field, after input validation and when the program is available, it also checks CLI presence and login only for selected providers: `codex login status` for Codex and `grok -p "Odpowiedz jednym słowem: OK"` for Grok, plus `claude auth status` when `reviewer-client.provider: claude` or `receiver-client.provider: claude`. A missing program does not check login. The Grok probe runs outside the project directory with tools disabled and with profile hooks isolated. With local managed policy present, doctor skips the probe and reports unconfirmed login. It requires a network and may incur the cost of a short AI call. It confirms login after a successful `OK` response. Doctor with `--engine-config` does not run engine commands or confirm project UUID, repo or models. The guides shipped in this package are local at `node_modules/robisie/docs/README.md` and `node_modules/robisie/docs/README.en.md`; no website fetch is needed.
|
|
11
11
|
|
|
12
12
|
Install robisie from npm in the prepared directory; run subsequent commands and agent sessions there. [Preparation](#wymagania) → [account](#konto) → [key](#klucz) → [installation](#instalacja) → [acceptance](#recenzja-i-odbior).
|
|
13
13
|
|
|
@@ -244,7 +244,7 @@ The human runs this in a terminal with the correct environment, in the installat
|
|
|
244
244
|
npx robisie doctor
|
|
245
245
|
```
|
|
246
246
|
|
|
247
|
-
Doctor checks the contract, project reads, configuration, roles, helper startup, `ROBISIE_KEY`, and free disk on the installation volume. For disk it prints HOLD below 15 GiB and unblock hysteresis from 18 GiB; below 15 GiB it exits 1. It shows the map: null or mixed assignments give exit 1; return to the complete shared-provider assignment in init. “Powyższe kontrole przeszły” means those checks passed, without proving the whole work loop.
|
|
247
|
+
Doctor checks the contract, project reads, configuration, roles, helper startup, `ROBISIE_KEY`, and free disk on the installation volume. For disk it prints HOLD below 15 GiB and unblock hysteresis from 18 GiB; below 15 GiB it exits 1. It shows the map: null or mixed assignments give exit 1; return to the complete shared-provider assignment in init. “Powyższe kontrole przeszły” means those checks passed, without proving the whole work loop. Ordinary doctor checks only the providers selected for the Worker, reviewer and receiver in the client configuration. An omitted receiver defaults to Grok. Without a client role registry, the “Gotowość wykonawców Codex–Grok” line reports readiness for the default pair. The same Grok probe applies (`grok -p "Odpowiedz jednym słowem: OK"`). The Grok probe runs outside the project directory with tools disabled and with profile hooks isolated. It requires a network and may incur the cost of a short AI call. It confirms login after a successful `OK` response.
|
|
248
248
|
|
|
249
249
|
Doctor runs the helper file via node, the agent via npx. `ROBISIE_PROJECT_CONTEXT` selects context later and does not change cwd for package lookup. Start the agent in the installation directory and ask it to list available tools from BOTH servers: `client-launch-context` (`get_launch_context`, `get_project_context`, `run_project_check`, `prepare_review`, `create_review_receipt`, `verify_stored_review`) and `ceo-client-launcher` (`spawn_builder`, `verify_review_receipt`). Result: both servers available with all these tools in that session. Do not call spawn_builder just as a probe. If a helper is missing, return to the installation cwd, check the local version and configuration, run init/doctor, then start a fresh agent session. Doctor alone does not confirm provider tool availability.
|
|
250
250
|
|
|
@@ -286,7 +286,7 @@ git commit -m "Przygotuj lokalne powitanie"
|
|
|
286
286
|
```
|
|
287
287
|
<!-- local-repo-setup:end -->
|
|
288
288
|
|
|
289
|
-
Save the entire JSON below as `robisie.config.json` in the repo directory, without overwriting existing configuration. **Replace** fictitious `project` with the UUID from authenticated `list_projects`, and the `tracks` UUID and name with a real track from that project’s board. Replace `engine.repo` with the absolute current repo path and `stateDir` with a separate directory **outside the repo**. Complete all four `roleRegistry` entries. In the local flow, `worker-client` can select Codex or Grok, and `reviewer-client` can select Codex, Claude or Grok. The Grok reviewer requires `provider: grok`, `model: grok-cli`, `effort: none`. The reviewer supports optional boolean `requireIndependentProvider`: absent or `true` requires another provider; a reviewer sharing the Worker provider requires explicit `false`. Every reviewer `false`, including Claude or Grok, marks review and acceptance as `partial` with the note “częściowa: bez niezależnego sprawdzenia”. Review always runs in a separate process. An unsupported pair or a configuration change during the card causes `HOLD clientPair`. For Codex roles, choose a real model available on your account and supported effort; this example uses `gpt-6.1-sol` / `high`, not fixture models. Set the Codex or Claude reviewer model and effort in the registry; the installed Grok CLI selects its model (`grok-cli` / `none`). The local flow requires CLI availability and login only for the providers selected for the Worker, reviewer and receiver; an omitted receiver means Grok. `doctor --engine-config` with explicit `engine.mode:host` checks structure offline, without CLI checks. With `engine.mode:client` or a missing `engine.mode` field, after input validation and when the program is available, it checks login only for selected providers: `codex login status` for Codex and `grok
|
|
289
|
+
Save the entire JSON below as `robisie.config.json` in the repo directory, without overwriting existing configuration. **Replace** fictitious `project` with the UUID from authenticated `list_projects`, and the `tracks` UUID and name with a real track from that project’s board. Replace `engine.repo` with the absolute current repo path and `stateDir` with a separate directory **outside the repo**. Complete all four `roleRegistry` entries. In the local flow, `worker-client` can select Codex or Grok, and `reviewer-client` can select Codex, Claude or Grok. The Grok reviewer requires `provider: grok`, `model: grok-cli`, `effort: none`. The reviewer supports optional boolean `requireIndependentProvider`: absent or `true` requires another provider; a reviewer sharing the Worker provider requires explicit `false`. Every reviewer `false`, including Claude or Grok, marks review and acceptance as `partial` with the note “częściowa: bez niezależnego sprawdzenia”. Review always runs in a separate process. An unsupported pair or a configuration change during the card causes `HOLD clientPair`. For Codex roles, choose a real model available on your account and supported effort; this example uses `gpt-6.1-sol` / `high`, not fixture models. Set the Codex or Claude reviewer model and effort in the registry; the installed Grok CLI selects its model (`grok-cli` / `none`). The local flow requires CLI availability and login only for the providers selected for the Worker, reviewer and receiver; an omitted receiver means Grok. `doctor --engine-config` with explicit `engine.mode:host` checks structure offline, without CLI checks. With `engine.mode:client` or a missing `engine.mode` field, after input validation and when the program is available, it checks login only for selected providers: `codex login status` for Codex and `grok -p "Odpowiedz jednym słowem: OK"` for Grok, plus `claude auth status` when `reviewer-client.provider: claude` or `receiver-client.provider: claude`. A missing program does not check login, and a missing CLI or unconfirmed login prevents readiness. The Grok probe runs outside the project directory with tools disabled and with profile hooks isolated. It requires a network and may incur the cost of a short AI call. It confirms login after a successful `OK` response. Parsing and this doctor do not prove model or provider availability. This execution registry is separate from the installer’s CEO/Builder/Quality Officer map.
|
|
290
290
|
|
|
291
291
|
The local review example assumes a working Grok CLI. If `grok --version` prints “no platform binary installed for darwin-arm64”, the command is on PATH but the macOS ARM64 binary is missing. Repair or install a working local version according to the provider's instructions, then check the version and login again. A trial on 18.11 then saw 1.0.89; that number is not a guarantee of the current release. Exit 0 from `grok models` does not prove login or a full review.
|
|
292
292
|
|
|
@@ -374,7 +374,7 @@ After changing the role pair, retry cards already in progress (“Retry work”)
|
|
|
374
374
|
```
|
|
375
375
|
<!-- local-engine-config:end -->
|
|
376
376
|
|
|
377
|
-
After replacing and saving configuration, prepare local engine inputs; init creates the project goal and tester safety list in `stateDir/inputs`. Continue only after ordinary doctor exits 0; `doctor --engine-config` alone does not check the account. Offline checks and no CLI apply only to explicit `engine.mode:host`; with `engine.mode:client` or a missing `engine.mode` field, probes follow input validation and only when the program is available
|
|
377
|
+
After replacing and saving configuration, prepare local engine inputs; init creates the project goal and tester safety list in `stateDir/inputs`. Continue only after ordinary doctor exits 0; `doctor --engine-config` alone does not check the robisie account. Offline checks and no CLI apply only to explicit `engine.mode:host`; with `engine.mode:client` or a missing `engine.mode` field, probes follow input validation and only when the program is available.
|
|
378
378
|
|
|
379
379
|
```sh
|
|
380
380
|
npx robisie init &&
|
|
@@ -709,6 +709,6 @@ After repair with an existing record, load the saved key as shown in Update befo
|
|
|
709
709
|
|
|
710
710
|
The installer does not start background services or the Builder on its own; after operator approval, the CEO can start the Builder through `spawn_builder`. Helpers run during agent sessions using the project directory (or `ROBISIE_PROJECT_CONTEXT`) as context. The installer contacts robisie to check the contract and key; the package file does not provide an account or AI provider access. One shared key identity does not provide three different permission levels. Acceptance requires independent review, evidence and the operator's approval.
|
|
711
711
|
|
|
712
|
-
Windows/WSL are unverified. `doctor --engine-config` with explicit `engine.mode:host` checks structure and local installation inputs offline, without CLI checks. With `engine.mode:client` or a missing `engine.mode` field, after input validation and when the program is available, it checks CLI presence and login only for selected providers: `codex login status` for Codex and `grok
|
|
712
|
+
Windows/WSL are unverified. `doctor --engine-config` with explicit `engine.mode:host` checks structure and local installation inputs offline, without CLI checks. With `engine.mode:client` or a missing `engine.mode` field, after input validation and when the program is available, it checks CLI presence and login only for selected providers: `codex login status` for Codex and `grok -p "Odpowiedz jednym słowem: OK"` for Grok, plus `claude auth status` when `reviewer-client.provider: claude` or `receiver-client.provider: claude`. A missing program does not check login. The Grok probe runs outside the project directory with tools disabled and with profile hooks isolated. It requires a network and may incur the cost of a short AI call. It confirms login after a successful `OK` response. Doctor with `--engine-config` does not run engine commands or confirm project UUID, repo existence or model availability.
|
|
713
713
|
|
|
714
714
|
The package engine (`dist/engine/tick.cjs`) is separate from the installer: it is started by `npx robisie factory run --engine-config ./robisie.config.json` on Linux or macOS for the client (`local`) or an explicit Robisie host (`mode: "host"`, `pr|delivered`). Other systems receive code 2 and a message. The `--once` option runs one tick without a pause and excludes an explicit `--interval`. Every nonzero tick result stops the supervisor („Fabryka zatrzymana: …”) with one diagnostic line on stderr; code 2 means an escalation (e.g. missing B key after receiver PASS, tester refusal, acceptance STOP) that must be resolved before retrying, and code 78 points to configuration repair. Real customer use on Linux will be proven in the D9 acceptance; a live macOS host switch and return require separate operator acceptance. Automatic FJ plans for customers are announced (“soon”) but are not in this release; the selector returns the true result.
|
package/docs/README.md
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
# robisie — od konta do odebranej karty (paczka 0.6.
|
|
1
|
+
# robisie — od konta do odebranej karty (paczka 0.6.14) <!-- x-release-please-version -->
|
|
2
2
|
|
|
3
3
|
W katalogu projektu z konfiguracją silnika uruchom `npx robisie init`, potem `npx robisie doctor`: init przygotuje cel projektu i listę ochrony testera, a doctor sprawdzi oba wejścia.
|
|
4
4
|
|
|
@@ -9,7 +9,7 @@ English: [README.en.md](README.en.md).
|
|
|
9
9
|
<!-- sekcja: dostepnosc -->
|
|
10
10
|
## Dostępność
|
|
11
11
|
|
|
12
|
-
Konto i klucz są potrzebne do init i pracy ról. `npx robisie doctor --engine-config ./robisie.config.json` przy jawnym `engine.mode:host` sprawdza offline strukturę konfiguracji i wejścia instalacji lokalnej, bez kontroli CLI. Przy `engine.mode:client` albo braku pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza obecność CLI oraz logowanie tylko wybranych dostawców: `codex login status` dla Codexa i `grok
|
|
12
|
+
Konto i klucz są potrzebne do init i pracy ról. `npx robisie doctor --engine-config ./robisie.config.json` przy jawnym `engine.mode:host` sprawdza offline strukturę konfiguracji i wejścia instalacji lokalnej, bez kontroli CLI. Przy `engine.mode:client` albo braku pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza obecność CLI oraz logowanie tylko wybranych dostawców: `codex login status` dla Codexa i `grok -p "Odpowiedz jednym słowem: OK"` dla Groka, a `claude auth status` przy `reviewer-client.provider: claude` lub `receiver-client.provider: claude`. Brak programu nie pozwala sprawdzić logowania. Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Przy lokalnej polityce zarządzanej doctor pomija sondę i zgłasza brak potwierdzenia logowania. Potwierdza logowanie po udanej odpowiedzi `OK`. Doctor z `--engine-config` nie wykonuje komend silnika i nie potwierdza UUID projektu, repo ani modeli. Przewodniki z tej paczki znajdziesz lokalnie w `node_modules/robisie/docs/README.md` i `node_modules/robisie/docs/README.en.md`; nie trzeba pobierać ich ze strony.
|
|
13
13
|
|
|
14
14
|
Zainstaluj robisie z npm w przygotowanym katalogu; w nim uruchamiaj dalsze polecenia i sesje agentów. [Przygotowanie](#wymagania) → [konto](#konto) → [klucz](#klucz) → [instalacja](#instalacja) → [odbiór](#recenzja-i-odbior).
|
|
15
15
|
|
|
@@ -287,7 +287,7 @@ Człowiek w terminalu z poprawnym środowiskiem, w katalogu instalacji:
|
|
|
287
287
|
npx robisie doctor
|
|
288
288
|
```
|
|
289
289
|
|
|
290
|
-
Doctor sprawdza kontrakt, odczyt projektów, konfigurację, role, start pomocników, `ROBISIE_KEY` oraz wolne miejsce na dysku instalacji. Przy dysku wypisuje HOLD poniżej 15 GiB i histerezę odblokowania od 18 GiB; poniżej 15 GiB kończy się exit 1. Pokazuje mapę: null lub mieszana mapa daje exit 1; wróć do pełnego przypisania jednego dostawcy w sekcji init. „Powyższe kontrole przeszły” oznacza powodzenie tych kontroli, nie pełnej pętli pracy.
|
|
290
|
+
Doctor sprawdza kontrakt, odczyt projektów, konfigurację, role, start pomocników, `ROBISIE_KEY` oraz wolne miejsce na dysku instalacji. Przy dysku wypisuje HOLD poniżej 15 GiB i histerezę odblokowania od 18 GiB; poniżej 15 GiB kończy się exit 1. Pokazuje mapę: null lub mieszana mapa daje exit 1; wróć do pełnego przypisania jednego dostawcy w sekcji init. „Powyższe kontrole przeszły” oznacza powodzenie tych kontroli, nie pełnej pętli pracy. Bez rejestru ról klienta linia „Gotowość wykonawców Codex–Grok” pokazuje gotowość domyślnej pary. Zwykły doctor sprawdza tylko dostawców wybranych dla Workera, recenzenta i odbiorcy w konfiguracji klienta. Brak wpisu odbiorcy oznacza Groka. Dla Groka używa tej samej sondy (`grok -p "Odpowiedz jednym słowem: OK"`). Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Potwierdza logowanie po udanej odpowiedzi `OK`.
|
|
291
291
|
|
|
292
292
|
Gdy klucz A widzi dokładnie jeden projekt, doctor odczytuje jego `reviewPolicy` przez `list_projects`. Dla `enforced` pokazuje „✓ Polityka enforced: TAK”. Dla `legacy` ostrzega, że odbiór B (`accept_review`) będzie odmawiany, i kieruje do operatora Robisie po ustawienie `enforced`. Starszy serwer bez pola, `null` lub błąd odczytu daje „NIE SPRAWDZONO” z powodem. Ta linia jest informacyjna i nie zmienia kodu wyjścia doctora. Klient tylko odczytuje politykę; ustawia ją wyłącznie operator.
|
|
293
293
|
|
|
@@ -331,7 +331,7 @@ git commit -m "Przygotuj lokalne powitanie"
|
|
|
331
331
|
```
|
|
332
332
|
<!-- local-repo-setup:end -->
|
|
333
333
|
|
|
334
|
-
Zapisz cały poniższy JSON jako `robisie.config.json` w katalogu repo, bez nadpisywania istniejącej konfiguracji. **Podmień** fikcyjne `project` na UUID z uwierzytelnionego `list_projects`, a UUID i nazwę `tracks` na rzeczywisty tor z tablicy tego projektu. Podmień `engine.repo` na absolutną ścieżkę bieżącego repo, a `stateDir` na osobny katalog **poza repo**. Uzupełnij wszystkie cztery wpisy `roleRegistry`. W lokalnym przebiegu `worker-client` może wybrać Codex albo Grok, a `reviewer-client` może wybrać Codex, Claude albo Grok. Recenzent Grok wymaga `provider: grok`, `model: grok-cli`, `effort: none`. Recenzent ma opcjonalne boolean `requireIndependentProvider`: brak lub `true` wymaga innego dostawcy; recenzent współdzielący dostawcę z Workerem wymaga jawnego `false`. Każde `false` recenzenta, także przy Claude lub Groku, zapisuje review i acceptance jako `partial` z notą „częściowa: bez niezależnego sprawdzenia”. Recenzja zawsze działa w osobnym procesie. Niedozwolona para lub zmiana konfiguracji w trakcie karty daje `HOLD clientPair`. Dla ról Codex wybierz rzeczywisty model dostępny na swoim koncie i obsługiwany effort; przykład używa `gpt-6.1-sol` / `high`, nie modeli fixture. Dla Codex i Claude ustaw model oraz effort recenzenta w rejestrze; model Groka wybiera zainstalowany Grok CLI (`grok-cli` / `none`). Lokalny przebieg wymaga CLI i logowania dostawców wybranych dla Workera, recenzenta i odbiorcy; brak wpisu odbiorcy oznacza Groka. `doctor --engine-config` przy jawnym `engine.mode:host` sprawdza strukturę offline, bez kontroli CLI. Przy `engine.mode:client` albo braku pola `engine.mode` sprawdza logowanie tylko wybranych dostawców po walidacji wejść i przy dostępnym programie: `codex login status` dla Codexa i `grok
|
|
334
|
+
Zapisz cały poniższy JSON jako `robisie.config.json` w katalogu repo, bez nadpisywania istniejącej konfiguracji. **Podmień** fikcyjne `project` na UUID z uwierzytelnionego `list_projects`, a UUID i nazwę `tracks` na rzeczywisty tor z tablicy tego projektu. Podmień `engine.repo` na absolutną ścieżkę bieżącego repo, a `stateDir` na osobny katalog **poza repo**. Uzupełnij wszystkie cztery wpisy `roleRegistry`. W lokalnym przebiegu `worker-client` może wybrać Codex albo Grok, a `reviewer-client` może wybrać Codex, Claude albo Grok. Recenzent Grok wymaga `provider: grok`, `model: grok-cli`, `effort: none`. Recenzent ma opcjonalne boolean `requireIndependentProvider`: brak lub `true` wymaga innego dostawcy; recenzent współdzielący dostawcę z Workerem wymaga jawnego `false`. Każde `false` recenzenta, także przy Claude lub Groku, zapisuje review i acceptance jako `partial` z notą „częściowa: bez niezależnego sprawdzenia”. Recenzja zawsze działa w osobnym procesie. Niedozwolona para lub zmiana konfiguracji w trakcie karty daje `HOLD clientPair`. Dla ról Codex wybierz rzeczywisty model dostępny na swoim koncie i obsługiwany effort; przykład używa `gpt-6.1-sol` / `high`, nie modeli fixture. Dla Codex i Claude ustaw model oraz effort recenzenta w rejestrze; model Groka wybiera zainstalowany Grok CLI (`grok-cli` / `none`). Lokalny przebieg wymaga CLI i logowania dostawców wybranych dla Workera, recenzenta i odbiorcy; brak wpisu odbiorcy oznacza Groka. `doctor --engine-config` przy jawnym `engine.mode:host` sprawdza strukturę offline, bez kontroli CLI. Przy `engine.mode:client` albo braku pola `engine.mode` sprawdza logowanie tylko wybranych dostawców po walidacji wejść i przy dostępnym programie: `codex login status` dla Codexa i `grok -p "Odpowiedz jednym słowem: OK"` dla Groka, a `claude auth status` przy `reviewer-client.provider: claude` lub `receiver-client.provider: claude`. Brak programu nie pozwala sprawdzić logowania. Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Potwierdza logowanie po udanej odpowiedzi `OK`. Brak CLI lub potwierdzenia logowania nie daje gotowości. Same parsowanie i ten doctor nie dowodzą dostępności modeli ani dostawców. Rejestr wykonania jest odrębny od mapy instalatora CEO/Builder/Quality Officer.
|
|
335
335
|
|
|
336
336
|
Lokalny przykład recenzji zakłada działające Grok CLI. Jeśli `grok --version` wypisze „no platform binary installed for darwin-arm64”, polecenie jest w PATH, ale brakuje binarki macOS ARM64. Napraw lub doinstaluj działającą lokalną wersję według instrukcji dostawcy, potem ponownie sprawdź wersję i logowanie. Próba z 18.11 zobaczyła wtedy 1.0.89; ta liczba nie jest gwarancją aktualnego wydania. Kod 0 z `grok models` nie dowodzi zalogowania ani pełnej recenzji.
|
|
337
337
|
|
|
@@ -421,7 +421,7 @@ Po zmianie pary ról karty w toku trzeba ponowić („Ponów pracę”) albo prz
|
|
|
421
421
|
```
|
|
422
422
|
<!-- local-engine-config:end -->
|
|
423
423
|
|
|
424
|
-
Po podmianie i zapisaniu konfiguracji przygotuj wejścia lokalnego silnika; init utworzy cel projektu i listę ochrony testera w `stateDir/inputs`. Kontynuuj dopiero po zwykłym doctor z exit 0; samo `doctor --engine-config` nie sprawdza konta. Offline i brak CLI dotyczą wyłącznie jawnego `engine.mode:host`; przy `engine.mode:client` albo braku pola `engine.mode` sondy następują po walidacji wejść i przy dostępnym programie
|
|
424
|
+
Po podmianie i zapisaniu konfiguracji przygotuj wejścia lokalnego silnika; init utworzy cel projektu i listę ochrony testera w `stateDir/inputs`. Kontynuuj dopiero po zwykłym doctor z exit 0; samo `doctor --engine-config` nie sprawdza konta robisie. Offline i brak CLI dotyczą wyłącznie jawnego `engine.mode:host`; przy `engine.mode:client` albo braku pola `engine.mode` sondy następują po walidacji wejść i przy dostępnym programie.
|
|
425
425
|
|
|
426
426
|
```sh
|
|
427
427
|
npx robisie init &&
|
|
@@ -755,6 +755,6 @@ Po naprawie przy istniejącej ewidencji wczytaj zapisany klucz według Aktualiza
|
|
|
755
755
|
|
|
756
756
|
Instalator nie uruchamia sam usług w tle ani Buildera; po zgodzie operatora CEO może uruchomić Buildera przez `spawn_builder`. Pomocniki działają podczas sesji agenta, z kontekstem katalogu projektu (lub `ROBISIE_PROJECT_CONTEXT`). Instalator łączy się z robisie w celu sprawdzenia kontraktu i klucza; plik paczki nie zapewnia konta ani dostępu do dostawcy AI. Jedna wspólna tożsamość klucza nie daje trzech różnych poziomów uprawnień. Lokalny odbiór automatyczny wymaga aktywnego silnika, niezależnej recenzji, dowodów użycia i chronionego odbioru kluczem B; decyzje operatora dotyczą eskalacji i jego granic produktu.
|
|
757
757
|
|
|
758
|
-
Windows/WSL są niezweryfikowane. `doctor --engine-config` przy jawnym `engine.mode:host` sprawdza offline strukturę konfiguracji i wejścia, bez kontroli CLI; przy `engine.mode:client` albo braku pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza CLI tylko wybranych dostawców: `codex login status` dla Codexa, `grok
|
|
758
|
+
Windows/WSL są niezweryfikowane. `doctor --engine-config` przy jawnym `engine.mode:host` sprawdza offline strukturę konfiguracji i wejścia, bez kontroli CLI; przy `engine.mode:client` albo braku pola `engine.mode`, po walidacji wejść i przy dostępnym programie, sprawdza CLI tylko wybranych dostawców: `codex login status` dla Codexa, `grok -p "Odpowiedz jednym słowem: OK"` dla Groka i `claude auth status` przy `reviewer-client.provider: claude` lub `receiver-client.provider: claude`. Brak programu nie pozwala sprawdzić logowania. Sonda Groka wymaga sieci i może kosztować tyle, co krótkie wywołanie AI. Działa poza katalogiem projektu, bez narzędzi i z izolacją hooków profilu. Potwierdza logowanie po udanej odpowiedzi `OK`. Doctor z `--engine-config` nie wykonuje komend silnika i nie potwierdza UUID projektu, istnienia repo ani dostępności modeli.
|
|
759
759
|
|
|
760
760
|
Silnik paczki (`dist/engine/tick.cjs`) jest odrębny od instalatora: uruchamia go `npx robisie factory run --engine-config ./robisie.config.json` na Linuxie lub macOS dla klienta (`local`) oraz jawnego hosta Robisie (`mode: "host"`, `pr|delivered`). Pozostałe systemy otrzymują kod 2 i komunikat. Opcja `--once` uruchamia jeden takt bez przerwy i wyklucza jawne `--interval`. Każdy niezerowy wynik taktu zatrzymuje nadzorcę („Fabryka zatrzymana: …”) z jedną linią diagnozy na stderr; kod 2 to eskalacja (np. brak klucza B po receiver PASS, odmowa testera, STOP odbioru) wymagająca rozstrzygnięcia przed ponowieniem, a kod 78 wskazuje konfigurację do poprawy. Realne użycie u klienta na Linuxie zostanie udowodnione w odbiorze D9; próba żywego hosta na macOS i jego powrotu wymaga osobnego odbioru operatora. Automatyczne plany FJ u klienta są zapowiedziane („wkrótce”), ale nie ma ich w tym wydaniu; selektor zwraca prawdziwy wynik.
|
package/package.json
CHANGED