robisie 0.5.47 → 0.5.48

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 CHANGED
@@ -1,5 +1,13 @@
1
1
  # Historia zmian klienta / Client changelog
2
2
 
3
+ ## [0.5.48](https://github.com/chuppa12/robisie-app/compare/client-v0.5.47...client-v0.5.48) (2026-11-16)
4
+
5
+
6
+ ### Factory Cards
7
+
8
+ * praca workera task-mwjfxw3d-oyg3t4 (auto-commit) ([f72af60](https://github.com/chuppa12/robisie-app/commit/f72af60684a90974f39280909d68a2bed3c3739f))
9
+ * praca workera task-mwjiqwru-slzebs (auto-commit) ([f2ef3d8](https://github.com/chuppa12/robisie-app/commit/f2ef3d8a30795d48db1b4a57702b31c3489f1e37))
10
+
3
11
  ## [0.5.47](https://github.com/chuppa12/robisie-app/compare/client-v0.5.46...client-v0.5.47) (2026-11-16)
4
12
 
5
13
 
package/README.md CHANGED
@@ -239,7 +239,19 @@ Backupy po uninstall mogą nadal zawierać klucz; zachowaj ich prywatność i w
239
239
 
240
240
  Worker Grok działa wyłącznie na Linux z działającym bubblewrap (`bwrap`). Na macOS klient odmawia przed startem: brak blokady sieci potomnych; wybierz Codex. Zainstaluj Grok CLI i zaloguj `grok login --device-auth`; zachowaj HOME i opcjonalne GROK_HOME (domyślnie `~/.grok`), bez kopiowania logowania. Codex nadal wymaga Codex CLI i `codex login --device-auth`. `doctor --engine-config` sprawdza obecność bubblewrap, ale nie dowodzi ochrony jądra.
241
241
 
242
- Przed startem silnik tworzy projektowy `.grok/sandbox.toml`: profil `robisie-<unikalny identyfikator próby>`, `extends = "workspace"`, `restrict_network = true`, `read_write = ["<absolutny stateDir>/worker-tmp/<próba>"]`, `deny = ["/tmp", "/var/tmp"]`. Start zamawia go przez `--sandbox robisie-…`; wbudowany GROK_SANDBOX nie zastępuje tego wyboru. Worktree, TMPDIR i dom Groka po realpath muszą leżeć poza deny. Silnik zachowuje HOME/GROK_HOME, reużywa TMPDIR próby i wyklucza dokładnie ten plik przez lokalny git info/exclude (także gdy `.git` worktree jest plikiem). Nie nadpisuje obcej konfiguracji, nie podąża za dowiązaniem profilu ani nie zapisuje globalnego TOML; identyczny własny plik jest idempotentny. Ponowna próba w tym samym worktree dopisuje osobny profil tylko po sprawdzeniu zgodności dotychczasowego pliku z kopią w artefaktach silnika; zachowuje wcześniejsze profile i ich kopie do weryfikacji dowodów. Brak kopii, jej zmiana lub dowiązanie oznacza odmowę. Różny globalny profil o tej samej nazwie wygrywa w Groku, dlatego klient odmawia przy konflikcie. Wcześniej zaufaj worktree w Grok CLI. Brak bubblewrap, zaufania, dostępnego/poprawnego profilu lub dowodu jego nałożenia odmawia; klient nie wraca automatycznie do Codexa. Wynik wymaga `sandbox-events.jsonl` z `enforced=true` dla tej próby oraz rzeczywistego modelu `grok-*`/xAI z procesu. `grok-cli` oznacza rodzinę CLI, a konkretny model w rejestrze wymaga równości; UNKNOWN służy tylko oczekiwaniu.
242
+ Worker Grok wymaga Grok CLI 1.0.77 albo nowszego. Poniżej tej wersji doctor i start odmawiają: zaktualizuj Grok CLI: `grok update`.
243
+
244
+ Worker Grok ma własny, pusty /tmp i /var/tmp: nie widzi plików ani gniazd w prawdziwym /tmp komputera, a zapis do /tmp zostaje w katalogu tej próby.
245
+
246
+ Testy, które uruchamiają lokalny serwer TCP, nie przejdą u Workera Groka (połączenie z localhost jest odrzucane). Do takiego repo wybierz Workera Codex.
247
+
248
+ Jeśli sam zaufałeś repozytorium w Grok CLI, worktree kart dziedziczą to zaufanie: sesja Workera załaduje AGENTS.md i haki tego repo, wewnątrz piaskownicy.
249
+
250
+ Reszta katalogu ~/.grok, poza ~/.grok/bin tylko do odczytu, pozostaje zapisywalna dla poleceń Workera. Zamknięcie jej to osobne discovery.
251
+
252
+ Start nie czyta ani nie zapisuje `trusted_folders.toml` i nie wymaga ręcznego zaufania per karta. Klient uruchamia Groka przez `bwrap --dev-bind / / --bind <TMPDIR próby>/tmp /tmp --bind <TMPDIR próby>/var-tmp /var/tmp --ro-bind <dom Groka>/bin <dom Groka>/bin -- grok …`. Oba montowane katalogi powstają puste w TMPDIR tej próby; istniejący katalog bin jest rozwiązywany przez realpath (domyślnie `~/.grok/bin`). Przed Grokiem krótkie lokalne polecenie z limitem czasu sprawdza te same montowania. Brak katalogu bin albo obsługi zagnieżdżania piaskownicy oznacza odmowę: wybierz Codex. Nie ma powrotu do Groka bez osłony.
253
+
254
+ Przed startem silnik tworzy projektowy `.grok/sandbox.toml`: profil `robisie-<unikalny identyfikator próby>`, `extends = "workspace"`, `restrict_network = true`, `read_write = ["<absolutny stateDir>/worker-tmp/<próba>"]`. Start zamawia go przez `--sandbox robisie-…`; wbudowany GROK_SANDBOX nie zastępuje tego wyboru. Worktree, TMPDIR i dom Groka po realpath muszą leżeć poza /tmp i /var/tmp. Silnik zachowuje HOME/GROK_HOME, reużywa TMPDIR próby i wyklucza dokładnie ten plik przez lokalny git info/exclude (także gdy `.git` worktree jest plikiem). Nie nadpisuje obcej konfiguracji, nie podąża za dowiązaniem profilu ani nie zapisuje globalnego TOML; identyczny własny plik jest idempotentny. Ponowna próba w tym samym worktree dopisuje osobny profil tylko po sprawdzeniu zgodności dotychczasowego pliku z kopią w artefaktach silnika; zachowuje wcześniejsze profile i ich kopie do weryfikacji dowodów. Brak kopii, jej zmiana lub dowiązanie oznacza odmowę. Różny globalny profil o tej samej nazwie wygrywa w Groku, dlatego klient odmawia przy konflikcie. Brak bubblewrap, dostępnego/poprawnego profilu lub dowodu jego nałożenia odmawia; klient nie wraca automatycznie do Codexa. Wynik wymaga `sandbox-events.jsonl` z `enforced=true` dla tej próby oraz rzeczywistego modelu `grok-*`/xAI z procesu. `grok-cli` oznacza rodzinę CLI, a konkretny model w rejestrze wymaga równości; UNKNOWN służy tylko oczekiwaniu.
243
255
 
244
256
  Granice: Landlock ma lukę ochrony metadanych; przed jądrem Linux 6.2 ma też lukę truncate. Blokada sieci obejmuje tylko procesy potomne na Linuksie; API/HTTP w procesie Groka pozostają otwarte. Testy na atrapach sprawdzają kontrakt startu, a rzeczywistą ochronę potwierdza dopiero sonda jądra po instalacji. Każda rola działa w osobnym procesie bez wznawiania sesji Workera lub recenzenta.
245
257
 
@@ -16,10 +16,11 @@ 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
- /** Provider CLI runs are replaceable so tests touch no real CLI or network. Output is never read or printed. */
19
+ /** Provider CLI runs are replaceable; only --version captures stdout, which 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
+ stdout?: string | null;
23
24
  };
24
25
  };
25
26
  /** Uses the registry already read by doctorEngineConfig, without reopening configuration. */
package/dist/commands.js CHANGED
@@ -260,11 +260,12 @@ function installedVersions(op, text) {
260
260
  }
261
261
  // ── doctor ───────────────────────────────────────────────────────────────────
262
262
  export const DOCTOR_SUCCESS = "Powyższe kontrole przeszły. Uruchom swojego agenta i poproś o rolę robisie CEO.";
263
- /** Provider CLI runs are replaceable so tests touch no real CLI or network. Output is never read or printed. */
263
+ /** Provider CLI runs are replaceable; only --version captures stdout, which is never printed. */
264
264
  export const loginIo = {
265
265
  run(binary, args, env, cwd) {
266
- const result = spawnSync(binary, args, { cwd, env, stdio: "ignore", timeout: 20_000, killSignal: "SIGKILL", shell: false });
267
- return { status: result.error ? null : result.status };
266
+ const version = args[0] === "--version";
267
+ const result = spawnSync(binary, args, { cwd, env, stdio: version ? ["ignore", "pipe", "ignore"] : "ignore", encoding: "utf8", timeout: 20_000, killSignal: "SIGKILL", shell: false });
268
+ return { status: result.error ? null : result.status, ...(version ? { stdout: result.stdout } : {}) };
268
269
  },
269
270
  };
270
271
  // The engine's provider env (engine-context/review-job allowlists), never the robisie keys.
@@ -351,6 +352,24 @@ export function doctorClientPair(ctx, registry) {
351
352
  validateClientRoles(registry["worker-client"], registry["reviewer-client"], registry["receiver-client"], ctx.platform);
352
353
  if (registry["worker-client"].provider === "grok" && !findProgram(ctx.cwd, ctx.env.PATH ?? "", "bwrap"))
353
354
  throw new RobisieError("Worker Grok wymaga bubblewrap (bwrap) do ochrony profilu na Linuksie.", "Zainstaluj bubblewrap albo wybierz Codex.");
355
+ if (registry["worker-client"].provider === "grok") {
356
+ const home = ctx.env.HOME || ctx.home;
357
+ const env = {};
358
+ for (const name of PAIR_ENV)
359
+ if (ctx.env[name] !== undefined)
360
+ env[name] = ctx.env[name];
361
+ env.HOME = home;
362
+ env.PATH = `${join(home, ".local/bin")}${delimiter}${env.PATH ?? ""}`;
363
+ const binary = findProgram(ctx.cwd, env.PATH, "grok");
364
+ let version = null;
365
+ try {
366
+ const result = binary ? loginIo.run(binary, ["--version"], env, ctx.cwd) : null;
367
+ version = result?.status === 0 && typeof result.stdout === "string" ? result.stdout.trim().match(/^grok (\d+)\.(\d+)\.(\d+)(?:\s|$)/) : null;
368
+ }
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
+ }
354
373
  const reviewer = registry["reviewer-client"];
355
374
  ctx.out(`Recenzent: ${reviewer.provider}/${reviewer.model}; niezależność: ${reviewer.requireIndependentProvider === false ? "częściowa: bez niezależnego sprawdzenia" : "wymagana"}.`);
356
375
  const receiver = registry["receiver-client"];
@@ -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.5.47";
3
+ export declare const PACKAGE_VERSION = "0.5.48";
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.5.47"; // x-release-please-version
3
+ export const PACKAGE_VERSION = "0.5.48"; // 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":"1db2b153c8e868fd5a4e1c0c09592eb8657270ac","dirty":false}
1
+ {"schema":1,"sha":"b37151f111bcb95f35a005553bf7e88e8166a3e5","dirty":false}
@@ -1725,6 +1725,6 @@
1725
1725
  "status": 0,
1726
1726
  "signal": null,
1727
1727
  "stdout": "v24.3.0\n",
1728
- "stderr": "(node:22007) 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"
1728
+ "stderr": "(node:22036) 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
  }
@@ -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.5.47";
37655
+ PACKAGE_VERSION = "0.5.48";
37656
37656
  SUPPORTED_CONTRACT_MAJOR = 1;
37657
37657
  DEFAULT_ORIGIN = "https://robisie.app";
37658
37658
  MCP_SERVER_NAME = "robisie";
@@ -78771,7 +78771,6 @@ function profileContents(profile, tmpdir7) {
78771
78771
  extends = "workspace"
78772
78772
  restrict_network = true
78773
78773
  read_write = [${JSON.stringify(tmpdir7)}]
78774
- deny = ["/tmp", "/var/tmp"]
78775
78774
  `;
78776
78775
  }
78777
78776
  function profileArchive(artifactsDir, contents) {
@@ -78790,9 +78789,6 @@ function prepareClientSandbox(cwd, tmpdir7, home, jobId, artifactsDir, client, e
78790
78789
  } catch {
78791
78790
  throw new Error("brak dzia\u0142aj\u0105cego bubblewrap (bwrap); zainstaluj bubblewrap albo wybierz Codex");
78792
78791
  }
78793
- const trust = record9(parse5(readRegular(import_node_path25.default.join(home, "trusted_folders.toml")).toString("utf8")));
78794
- if (record9(record9(trust?.folders)?.[cwd])?.trusted !== true)
78795
- throw new Error("brak zaufania folderu Groka; zaufaj temu worktree w Grok CLI przed startem");
78796
78792
  const profile = clientProfile(cwd, tmpdir7, jobId), contents = profileContents(profile, tmpdir7);
78797
78793
  const global2 = optionalRegular(import_node_path25.default.join(home, "sandbox.toml"));
78798
78794
  if (global2) {
@@ -78875,7 +78871,7 @@ function assertClientSandbox(worker, sandbox) {
78875
78871
  if (bytes.length <= sandbox.offset) throw new Error("Brak dowodu na\u0142o\u017Cenia profilu Groka");
78876
78872
  const events = bytes.subarray(sandbox.offset).toString("utf8").split(/\r?\n/).filter(Boolean).map((line2) => record9(JSON.parse(line2)));
78877
78873
  const applied = events.filter((e) => e?.profile === sandbox.profile && e?.workspace === worker.cwd && e?.event_type === "ProfileApplied");
78878
- if (applied.length !== 1 || applied[0]?.enforced !== true || applied[0]?.restrict_network !== true || !String(applied[0]?.platform).startsWith("linux/") || !Number.isFinite(Date.parse(String(applied[0]?.timestamp))) || Date.parse(String(applied[0]?.timestamp)) < Date.parse(worker.startedAt) || !Array.isArray(applied[0]?.read_write_paths) || !(0, import_node_util5.isDeepStrictEqual)(applied[0].read_write_paths.filter((p) => p !== "/tmp" && p !== "/var/tmp").sort(), [worker.cwd, sandbox.home, sandbox.tmpdir].sort()) || !Array.isArray(applied[0]?.deny_paths) || !["/tmp", "/var/tmp"].every((p) => applied[0].deny_paths.includes(p)))
78874
+ if (applied.length !== 1 || applied[0]?.enforced !== true || applied[0]?.restrict_network !== true || !String(applied[0]?.platform).startsWith("linux/") || !Number.isFinite(Date.parse(String(applied[0]?.timestamp))) || Date.parse(String(applied[0]?.timestamp)) < Date.parse(worker.startedAt) || !Array.isArray(applied[0]?.read_write_paths) || !(0, import_node_util5.isDeepStrictEqual)([...new Set(applied[0].read_write_paths)].sort(), [worker.cwd, sandbox.home, sandbox.tmpdir, "/tmp", "/var/tmp"].sort()))
78879
78875
  throw new Error("Brak zgodnego dowodu na\u0142o\u017Cenia profilu Groka (enforced=true)");
78880
78876
  }
78881
78877
  function startWorker(input, deps = {}) {
@@ -78932,6 +78928,7 @@ function startWorker(input, deps = {}) {
78932
78928
  const runner = (0, import_node_url2.fileURLToPath)(__robisie_engine_bundle_url_5567750a);
78933
78929
  const grok = input.selection.backend === "grok";
78934
78930
  let clientSandbox;
78931
+ let clientMounts;
78935
78932
  let cwd = input.cwd;
78936
78933
  let env = input.env;
78937
78934
  let binary = input.openCodeBinary ?? "opencode";
@@ -78944,7 +78941,32 @@ function startWorker(input, deps = {}) {
78944
78941
  const home = (0, import_node_fs23.realpathSync)(input.env.GROK_HOME || import_node_path25.default.join(input.env.HOME, ".grok"));
78945
78942
  if (input.client) {
78946
78943
  if ((input.client.platform ?? process.platform) !== "linux") throw new Error("Worker Grok: brak blokady sieci potomnych na tej platformie. Wybierz Codex.");
78944
+ let version3 = null;
78945
+ try {
78946
+ const output = (0, import_node_child_process10.execFileSync)(input.grokBinary ?? "grok", ["--version"], { cwd, env: input.env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 5e3 });
78947
+ version3 = typeof output === "string" ? output.trim().match(/^grok (\d+)\.(\d+)\.(\d+)(?:\s|$)/) : null;
78948
+ } catch {
78949
+ }
78950
+ if (!version3 || !(Number(version3[1]) > 1 || Number(version3[1]) === 1 && (Number(version3[2]) > 0 || Number(version3[3]) >= 77)))
78951
+ throw new Error("Worker Grok wymaga Grok CLI 1.0.77 albo nowszego. Zaktualizuj Grok CLI: `grok update`.");
78947
78952
  clientSandbox = prepareClientSandbox(cwd, temporary, home, localJobId, import_node_path25.default.resolve(input.artifactsDir), input.client, input.env);
78953
+ const binPath = import_node_path25.default.join(home, "bin");
78954
+ let bin;
78955
+ try {
78956
+ bin = (0, import_node_fs23.realpathSync)(binPath);
78957
+ if (!(0, import_node_fs23.lstatSync)(bin).isDirectory()) throw new Error("wymagany katalog");
78958
+ } catch (error48) {
78959
+ throw new Error(`Niedost\u0119pny katalog Groka ${binPath}: ${errorText2(error48)}`);
78960
+ }
78961
+ const tmp = import_node_path25.default.join(temporary, "tmp"), varTmp = import_node_path25.default.join(temporary, "var-tmp");
78962
+ (0, import_node_fs23.mkdirSync)(tmp, { mode: 448 });
78963
+ (0, import_node_fs23.mkdirSync)(varTmp, { mode: 448 });
78964
+ clientMounts = ["--dev-bind", "/", "/", "--bind", tmp, "/tmp", "--bind", varTmp, "/var/tmp", "--ro-bind", bin, bin, "--"];
78965
+ try {
78966
+ (0, import_node_child_process10.execFileSync)("bwrap", [...clientMounts, "/bin/true"], { cwd, env: input.env, stdio: "pipe", timeout: 5e3 });
78967
+ } catch (error48) {
78968
+ throw new Error(`Nie mo\u017Cna u\u017Cy\u0107 zagnie\u017Cd\u017Conej piaskownicy bubblewrap; wybierz Codex: ${errorText2(error48)}`);
78969
+ }
78948
78970
  } else env = { ...input.env, GROK_HOME: home };
78949
78971
  binary = input.grokBinary ?? "grok";
78950
78972
  args = [
@@ -78984,6 +79006,10 @@ function startWorker(input, deps = {}) {
78984
79006
  "--no-auto-update"
78985
79007
  ];
78986
79008
  if (clientSandbox && clientSandbox.requestedModel !== "grok-cli") args.push("--model", clientSandbox.requestedModel);
79009
+ if (clientMounts) {
79010
+ args = [...clientMounts, binary, ...args];
79011
+ binary = "bwrap";
79012
+ }
78987
79013
  } catch (error48) {
78988
79014
  return { ok: false, status: "blocked", mayHaveStarted: false, reason: errorText2(error48) };
78989
79015
  }
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.5.47 \u2014 plik zarz\u0105dzany przez `npx robisie`; `npx robisie uninstall` go usunie -->";
20
+ export declare const MANAGED_LINE = "<!-- robisie:managed 0.5.48 \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.5.47) <!-- x-release-please-version -->
1
+ # robisie — from account to accepted card (package 0.5.48) <!-- 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
 
@@ -286,7 +286,19 @@ Save the entire JSON below as `robisie.config.json` in the repo directory, witho
286
286
 
287
287
  The Grok Worker runs only on Linux with working bubblewrap (`bwrap`). On macOS the client refuses before startup because child-process network blocking is unavailable; select Codex. Install Grok CLI and sign in with `grok login --device-auth`; preserve HOME and optional GROK_HOME (default `~/.grok`) without relocating login. Codex still needs Codex CLI and `codex login --device-auth`. `doctor --engine-config` checks bubblewrap availability, but does not prove kernel enforcement.
288
288
 
289
- Before startup the engine creates project `.grok/sandbox.toml`: profile `robisie-<unique attempt identifier>`, `extends = "workspace"`, `restrict_network = true`, `read_write = ["<absolute stateDir>/worker-tmp/<attempt>"]`, `deny = ["/tmp", "/var/tmp"]`. Startup requests it through `--sandbox robisie-…`; built-in GROK_SANDBOX does not replace this selection. The realpath of the worktree, TMPDIR and Grok home must be outside deny. The engine preserves HOME/GROK_HOME, reuses the attempt TMPDIR and excludes exactly this file through local git info/exclude (including worktrees whose `.git` is a file). It never overwrites foreign configuration, follows profile symlinks or writes global TOML; an identical owned file is idempotent. A retry in the same worktree appends a separate profile only after matching the existing file against its copy in the engine artifacts; earlier profiles and copies remain available for evidence verification. A missing, modified or symlinked copy causes refusal. A different global profile with the same name wins in Grok, so the client refuses a conflict. Trust the worktree in Grok CLI beforehand. Missing bubblewrap, folder trust, an available/valid profile or evidence of enforcement causes refusal; the client has no automatic Codex fallback. Results require `sandbox-events.jsonl` with `enforced=true` for this attempt and the actual process model `grok-*`/xAI. `grok-cli` selects the CLI family, while a concrete registry model must match exactly; UNKNOWN is only a waiting state.
289
+ The Grok Worker requires Grok CLI 1.0.77 or newer. Below that, doctor and startup refuse: update Grok CLI with `grok update`.
290
+
291
+ The Grok Worker has its own empty /tmp and /var/tmp: it does not see files or sockets in the computer's real /tmp, and a write to /tmp stays in this attempt's directory.
292
+
293
+ Tests that start a local TCP server will not pass under the Grok Worker (localhost is refused). For such a repo, select the Codex Worker.
294
+
295
+ If you trusted the repository in Grok CLI yourself, card worktrees inherit that trust: the Worker session loads that repo's AGENTS.md and hooks, inside the sandbox.
296
+
297
+ The rest of ~/.grok, other than read-only ~/.grok/bin, stays writable by Worker commands. Closing it is a separate discovery.
298
+
299
+ Startup does not read or write `trusted_folders.toml` and requires no manual trust step per card. The client starts Grok through `bwrap --dev-bind / / --bind <attempt TMPDIR>/tmp /tmp --bind <attempt TMPDIR>/var-tmp /var/tmp --ro-bind <Grok home>/bin <Grok home>/bin -- grok …`. Both mounted directories are created empty inside this attempt's TMPDIR; the existing bin directory is resolved through realpath (`~/.grok/bin` by default). Before Grok starts, a short local command checks these same mounts with a timeout. A missing bin directory or unavailable nested sandbox causes refusal: select Codex. No unwrapped Grok fallback is used.
300
+
301
+ Before startup the engine creates project `.grok/sandbox.toml`: profile `robisie-<unique attempt identifier>`, `extends = "workspace"`, `restrict_network = true`, `read_write = ["<absolute stateDir>/worker-tmp/<attempt>"]`. Startup requests it through `--sandbox robisie-…`; built-in GROK_SANDBOX does not replace this selection. The realpath of the worktree, TMPDIR and Grok home must be outside /tmp and /var/tmp. The engine preserves HOME/GROK_HOME, reuses the attempt TMPDIR and excludes exactly this file through local git info/exclude (including worktrees whose `.git` is a file). It never overwrites foreign configuration, follows profile symlinks or writes global TOML; an identical owned file is idempotent. A retry in the same worktree appends a separate profile only after matching the existing file against its copy in the engine artifacts; earlier profiles and copies remain available for evidence verification. A missing, modified or symlinked copy causes refusal. A different global profile with the same name wins in Grok, so the client refuses a conflict. Missing bubblewrap, an available/valid profile or evidence of enforcement causes refusal; the client has no automatic Codex fallback. Results require `sandbox-events.jsonl` with `enforced=true` for this attempt and the actual process model `grok-*`/xAI. `grok-cli` selects the CLI family, while a concrete registry model must match exactly; UNKNOWN is only a waiting state.
290
302
 
291
303
  Limits: Landlock has a metadata protection gap and, before Linux kernel 6.2, a truncate gap. Network blocking covers only child processes on Linux; API/HTTP inside Grok remain open. Offline mock tests check the startup contract; only a kernel probe after installation establishes actual enforcement. Each role runs in a separate process without resuming Worker or reviewer sessions.
292
304
 
package/docs/README.md CHANGED
@@ -1,4 +1,4 @@
1
- # robisie — od konta do odebranej karty (paczka 0.5.47) <!-- x-release-please-version -->
1
+ # robisie — od konta do odebranej karty (paczka 0.5.48) <!-- 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
 
@@ -333,7 +333,19 @@ Worker Codex na Linuksie może uruchamiać testy tworzące procesy, ale proxy de
333
333
 
334
334
  Worker Grok działa wyłącznie na Linux z działającym bubblewrap (`bwrap`). Na macOS klient odmawia przed startem: brak blokady sieci potomnych; wybierz Codex. Zainstaluj Grok CLI i zaloguj `grok login --device-auth`; zachowaj HOME i opcjonalne GROK_HOME (domyślnie `~/.grok`), bez kopiowania logowania. Codex nadal wymaga Codex CLI i `codex login --device-auth`. `doctor --engine-config` sprawdza obecność bubblewrap, ale nie dowodzi ochrony jądra.
335
335
 
336
- Przed startem silnik tworzy projektowy `.grok/sandbox.toml`: profil `robisie-<unikalny identyfikator próby>`, `extends = "workspace"`, `restrict_network = true`, `read_write = ["<absolutny stateDir>/worker-tmp/<próba>"]`, `deny = ["/tmp", "/var/tmp"]`. Start zamawia go przez `--sandbox robisie-…`; wbudowany GROK_SANDBOX nie zastępuje tego wyboru. Worktree, TMPDIR i dom Groka po realpath muszą leżeć poza deny. Silnik zachowuje HOME/GROK_HOME, reużywa TMPDIR próby i wyklucza dokładnie ten plik przez lokalny git info/exclude (także gdy `.git` worktree jest plikiem). Nie nadpisuje obcej konfiguracji, nie podąża za dowiązaniem profilu ani nie zapisuje globalnego TOML; identyczny własny plik jest idempotentny. Ponowna próba w tym samym worktree dopisuje osobny profil tylko po sprawdzeniu zgodności dotychczasowego pliku z kopią w artefaktach silnika; zachowuje wcześniejsze profile i ich kopie do weryfikacji dowodów. Brak kopii, jej zmiana lub dowiązanie oznacza odmowę. Różny globalny profil o tej samej nazwie wygrywa w Groku, dlatego klient odmawia przy konflikcie. Wcześniej zaufaj worktree w Grok CLI. Brak bubblewrap, zaufania, dostępnego/poprawnego profilu lub dowodu jego nałożenia odmawia; klient nie wraca automatycznie do Codexa. Wynik wymaga `sandbox-events.jsonl` z `enforced=true` dla tej próby oraz rzeczywistego modelu `grok-*`/xAI z procesu. `grok-cli` oznacza rodzinę CLI, a konkretny model w rejestrze wymaga równości; UNKNOWN służy tylko oczekiwaniu.
336
+ Worker Grok wymaga Grok CLI 1.0.77 albo nowszego. Poniżej tej wersji doctor i start odmawiają: zaktualizuj Grok CLI: `grok update`.
337
+
338
+ Worker Grok ma własny, pusty /tmp i /var/tmp: nie widzi plików ani gniazd w prawdziwym /tmp komputera, a zapis do /tmp zostaje w katalogu tej próby.
339
+
340
+ Testy, które uruchamiają lokalny serwer TCP, nie przejdą u Workera Groka (połączenie z localhost jest odrzucane). Do takiego repo wybierz Workera Codex.
341
+
342
+ Jeśli sam zaufałeś repozytorium w Grok CLI, worktree kart dziedziczą to zaufanie: sesja Workera załaduje AGENTS.md i haki tego repo, wewnątrz piaskownicy.
343
+
344
+ Reszta katalogu ~/.grok, poza ~/.grok/bin tylko do odczytu, pozostaje zapisywalna dla poleceń Workera. Zamknięcie jej to osobne discovery.
345
+
346
+ Start nie czyta ani nie zapisuje `trusted_folders.toml` i nie wymaga ręcznego zaufania per karta. Klient uruchamia Groka przez `bwrap --dev-bind / / --bind <TMPDIR próby>/tmp /tmp --bind <TMPDIR próby>/var-tmp /var/tmp --ro-bind <dom Groka>/bin <dom Groka>/bin -- grok …`. Oba montowane katalogi powstają puste w TMPDIR tej próby; istniejący katalog bin jest rozwiązywany przez realpath (domyślnie `~/.grok/bin`). Przed Grokiem krótkie lokalne polecenie z limitem czasu sprawdza te same montowania. Brak katalogu bin albo obsługi zagnieżdżania piaskownicy oznacza odmowę: wybierz Codex. Nie ma powrotu do Groka bez osłony.
347
+
348
+ Przed startem silnik tworzy projektowy `.grok/sandbox.toml`: profil `robisie-<unikalny identyfikator próby>`, `extends = "workspace"`, `restrict_network = true`, `read_write = ["<absolutny stateDir>/worker-tmp/<próba>"]`. Start zamawia go przez `--sandbox robisie-…`; wbudowany GROK_SANDBOX nie zastępuje tego wyboru. Worktree, TMPDIR i dom Groka po realpath muszą leżeć poza /tmp i /var/tmp. Silnik zachowuje HOME/GROK_HOME, reużywa TMPDIR próby i wyklucza dokładnie ten plik przez lokalny git info/exclude (także gdy `.git` worktree jest plikiem). Nie nadpisuje obcej konfiguracji, nie podąża za dowiązaniem profilu ani nie zapisuje globalnego TOML; identyczny własny plik jest idempotentny. Ponowna próba w tym samym worktree dopisuje osobny profil tylko po sprawdzeniu zgodności dotychczasowego pliku z kopią w artefaktach silnika; zachowuje wcześniejsze profile i ich kopie do weryfikacji dowodów. Brak kopii, jej zmiana lub dowiązanie oznacza odmowę. Różny globalny profil o tej samej nazwie wygrywa w Groku, dlatego klient odmawia przy konflikcie. Brak bubblewrap, dostępnego/poprawnego profilu lub dowodu jego nałożenia odmawia; klient nie wraca automatycznie do Codexa. Wynik wymaga `sandbox-events.jsonl` z `enforced=true` dla tej próby oraz rzeczywistego modelu `grok-*`/xAI z procesu. `grok-cli` oznacza rodzinę CLI, a konkretny model w rejestrze wymaga równości; UNKNOWN służy tylko oczekiwaniu.
337
349
 
338
350
  Granice: Landlock ma lukę ochrony metadanych; przed jądrem Linux 6.2 ma też lukę truncate. Blokada sieci obejmuje tylko procesy potomne na Linuksie; API/HTTP w procesie Groka pozostają otwarte. Testy na atrapach sprawdzają kontrakt startu, a rzeczywistą ochronę potwierdza dopiero sonda jądra po instalacji. Każda rola działa w osobnym procesie bez wznawiania sesji Workera lub recenzenta.
339
351
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "robisie",
3
- "version": "0.5.47",
3
+ "version": "0.5.48",
4
4
  "description": "Instalator klienta robisie: łączy agenta (Claude Code, Codex CLI, OpenCode) z tablicą robisie i instaluje role klienta.",
5
5
  "license": "UNLICENSED",
6
6
  "type": "module",