robisie 0.1.0 → 0.1.1

package/dist/role-results.js

@@ -0,0 +1,42 @@
+// GPT-6 Sol (Z53, 2026-09-22) pogrubia linie STATUS/WERDYKT; dopasowujemy na kopii bez * i backtickow, raport zostaje oryginalny.
+export function plainMarkers(text) {
+    return text.replace(/[*`]/g, "");
+}
+/** Wyciąga sekcję RAPORT MASZYNISTY z wyjścia workera. Brak sekcji = UNKNOWN (nigdy nie zgaduj sukcesu). */
+export function parseWorkerOutput(output) {
+    const idx = output.lastIndexOf("### RAPORT MASZYNISTY");
+    if (idx < 0)
+        return { status: "UNKNOWN", report: output.slice(-1500) };
+    const report = output.slice(idx);
+    const plain = plainMarkers(report);
+    // Szablon z briefu ("STATUS: WORKER_FINISHED | ALREADY_DONE | ...") NIE jest raportem — zmierzone 2026-09-10
+    // (karta 3999702e): worker zakonczyl PYTANIEM bez raportu, a wynik helpera zawieral tresc briefu ->
+    // Maszynista odczytal szablon jako WORKER_FINISHED i przeniosl karte do in_review bez zadnego diffu.
+    if (/STATUS:\s*WORKER_FINISHED\s*\|/.test(plain) || plain.includes("(WORKER_FINISHED = "))
+        return { status: "UNKNOWN", report: report.slice(0, 1500) };
+    if (/^[-*]?\s*STATUS:\s*ACTIONABLE_BLOCKER\b(?!\s*\|)/m.test(plain))
+        return { status: "ACTIONABLE_BLOCKER", report };
+    const m = plain.match(/STATUS:\s*(WORKER_FINISHED|DONE|ALREADY_DONE|FAILED|NEEDS_HUMAN)\b(?!\s*\|)/);
+    const raw = m?.[1];
+    const status = raw === "DONE" ? "WORKER_FINISHED" : (raw ?? "UNKNOWN");
+    return { status, report };
+}
+/** Ostatnie wystąpienie wygrywa, także gdy jest niepoprawne. Szablon nie jest PASS. */
+export function parseReviewVerdict(text) {
+    // Szablon z prompta ("VERDICT: PASS albo VERDICT: FAIL - <powody>") nie jest werdyktem - usun go przed czytaniem.
+    const cleaned = text.replace(/VERDICT:\s*PASS\s+albo\s+VERDICT:\s*FAIL[^\n]*/gi, "");
+    // Zmierzone 2026-09-10 (karta 973a2a79, runda 2): codex review pisze werdykt W SRODKU akapitu
+    // ("...delivered cards. VERDICT: FAIL - 1. Tester reads..."), nie na poczatku linii -> ostatnie wystapienie
+    // PASS/FAIL po "VERDICT:" wygrywa, niezaleznie od pozycji w linii.
+    const idx = cleaned.lastIndexOf("VERDICT:");
+    if (idx >= 0) {
+        const last = cleaned.slice(idx).match(/^VERDICT:\s*([A-Z_]+)/)?.[1]; // OSTATNI werdykt rozstrzyga; PASS/FAIL, cokolwiek innego = niepoprawny format
+        return last === "PASS" || last === "FAIL" ? last : "UNAVAILABLE";
+    }
+    // Bez linii VERDICT: lista znalezisk "[P1] ..."/"[P2] ..." = FAIL; jawne "brak uwag" = PASS; reszta = UNAVAILABLE.
+    if (/\[P[0-2]\]/.test(cleaned))
+        return "FAIL";
+    if (/no (issues|findings|problems) found|brak (uwag|zastrzezen|zastrzeżeń|znalezisk)|nie znaleziono (problem|blęd|błęd)/i.test(cleaned))
+        return "PASS";
+    return "UNAVAILABLE";
+}

package/dist/roles.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The three client roles, copied verbatim from the repo's `.claude/agents/*-client.md`
+ * (scripts/sync-assets.mjs; drift test in test/assets-drift.test.ts). Bodies are never rewritten —
+ * only the frontmatter is adapted to each agent's format, plus one adapter section in front.
+ */
+export declare const ROLE_FILES: readonly ["ceo-client.md", "manager-builder-client.md", "quality-officer-client.md"];
+export type RoleKind = "ceo" | "builder" | "quality";
+export interface Role {
+    file: (typeof ROLE_FILES)[number];
+    name: string;
+    kind: RoleKind;
+    label: string;
+    description: string;
+    frontmatter: string;
+    body: string;
+}
+export declare function rolesDir(): string;
+export declare function parseRole(file: Role["file"], text: string): Role;
+export declare function loadRoles(dir?: string): Role[];
+export declare const MANAGED_LINE = "<!-- robisie:managed 0.1.1 \u2014 plik zarz\u0105dzany przez `npx robisie`; `npx robisie uninstall` go usunie -->";
+export type AgentFlavor = "claude" | "codex" | "opencode";
+/** How the operator starts the Builder for one card in its own session (the card id is not a secret). */
+export declare function builderStartCommand(flavor: AgentFlavor, codexRolePath?: string): string;
+/** The one section robisie adds: how the unchanged contract maps onto this agent. */
+export declare function adapterSection(flavor: AgentFlavor, codexRolePath?: string): string;
+/** Claude agent frontmatter: the hosted `robisie` entry stays; each stdio helper (repo-only script) runs from this package. */
+export declare function claudeFrontmatter(frontmatter: string): string;
+export declare function renderClaudeAgent(role: Role): string;
+export declare function renderOpenCodeAgent(role: Role): string;
+export declare function renderCodexRole(role: Role, builderRolePath?: string): string;

package/dist/roles.js

@@ -14,26 +14,27 @@ export function rolesDir() {
     // src/roles.ts and dist/roles.js both sit one level below the package root.
     return join(dirname(fileURLToPath(import.meta.url)), "..", "roles");
 }
-function kindOf(name) {
-    if (name.startsWith("ceo"))
-        return "ceo";
-    if (name.startsWith("quality"))
-        return "quality";
-    return "builder";
-}
+const KINDS = {
+    "ceo-client.md": "ceo",
+    "manager-builder-client.md": "builder",
+    "quality-officer-client.md": "quality",
+};
 export function parseRole(file, text) {
-    const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(text);
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(text);
     if (!match)
-        throw new RobisieError(`Rola ${file} nie ma nagłówka (frontmatter).`, "Przeinstaluj otrzymany plik .tgz w katalogu instalacji: `npm i ./robisie-0.1.0.tgz` (użyj nazwy otrzymanego pliku), potem lokalne `npx robisie init` i `npx robisie doctor`.");
-    const frontmatter = match[1] ?? "";
+        throw new RobisieError(`Rola ${file} nie ma nagłówka (frontmatter).`, "W katalogu projektu wykonaj `npm uninstall robisie`, potem `npm i robisie@<wersja-zgodna-z-kontraktem-serwera>` (zastąp placeholder numerem zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+    const frontmatter = (match[1] ?? "").replace(/\r\n/g, "\n");
     const field = (key) => {
         const line = frontmatter.split("\n").find((l) => l.startsWith(`${key}:`));
         return line ? line.slice(key.length + 1).trim().replace(/^"(.*)"$/, "$1") : "";
     };
     const name = field("name");
     if (!name)
-        throw new RobisieError(`Rola ${file} nie ma nazwy.`, "Przeinstaluj otrzymany plik .tgz w katalogu instalacji: `npm i ./robisie-0.1.0.tgz` (użyj nazwy otrzymanego pliku), potem lokalne `npx robisie init` i `npx robisie doctor`.");
-    const kind = kindOf(name);
+        throw new RobisieError(`Rola ${file} nie ma nazwy.`, "W katalogu projektu wykonaj `npm uninstall robisie`, potem `npm i robisie@<wersja-zgodna-z-kontraktem-serwera>` (zastąp placeholder numerem zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+    if (frontmatter.split("\n").filter((line) => /^name[ \t]*:/.test(line)).length !== 1 || name !== file.slice(0, -3)) {
+        throw new RobisieError(`Rola ${file} ma niezgodną lub niejednoznaczną nazwę.`, "W katalogu projektu wykonaj `npm uninstall robisie`, potem `npm i robisie@<wersja-zgodna-z-kontraktem-serwera>` (zastąp placeholder numerem zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+    }
+    const kind = KINDS[file];
     return { file, name, kind, label: LABELS[kind], description: field("description"), frontmatter, body: match[2] ?? "" };
 }
 export function loadRoles(dir = rolesDir()) {
@@ -43,7 +44,7 @@ export function loadRoles(dir = rolesDir()) {
             text = readFileSync(join(dir, file), "utf8");
         }
         catch (error) {
-            throw new RobisieError(`Brak pliku roli ${file} w paczce: ${errorMessage(error)}`, "Przeinstaluj otrzymany plik .tgz w katalogu instalacji: `npm i ./robisie-0.1.0.tgz` (użyj nazwy otrzymanego pliku), potem lokalne `npx robisie init` i `npx robisie doctor`.");
+            throw new RobisieError(`Brak pliku roli ${file} w paczce: ${errorMessage(error)}`, "W katalogu projektu wykonaj `npm uninstall robisie`, potem `npm i robisie@<wersja-zgodna-z-kontraktem-serwera>` (zastąp placeholder numerem zgodnego wydania), potem lokalne `npx robisie init` i `npx robisie doctor`.");
         }
         return parseRole(file, text);
     });
@@ -72,9 +73,11 @@ export function adapterSection(flavor, codexRolePath) {
         "",
         `- Board tools come from the MCP server \`robisie\`; the local helper servers ${HELPER_SERVERS.map((name) => `\`${name}\``).join(" and ")} are installed too (started as \`npx -y ${PACKAGE_NAME}@${PACKAGE_VERSION} mcp <server>\`). ${TOOL_NAMING[flavor]}`,
         "- Run every role from the customer project's directory: npx must find the installed package in cwd. ROBISIE_PROJECT_CONTEXT does not change cwd; the helpers select that context only after startup. Doctor probes the helper file via node, not the agent's npx lookup. In the agent session, list tools from both client-launch-context and ceo-client-launcher before work.",
-        "- The Builder reads its card from `ROBISIE_CARD_REF`, which the operator sets when starting the Builder's session.",
-        `- \`spawn_builder\` needs a project launcher that a customer project normally does not have, so it fails closed and the card stays \`ready\`. Then give the operator this one command to run in a new terminal in the project directory, with the real card id: \`${builderStartCommand(flavor, codexRolePath)}\`. After the operator says it is running, do the one post-launch \`get_task\` read the contract requires.`,
+        "- The Builder reads its card from `ROBISIE_CARD_REF`, which the packaged launcher sets when starting the Builder's session.",
+        "- Use `spawn_builder` to launch the Builder with the launcher shipped in this package; no project-local scripts are required. It selects the Builder provider saved by `npx robisie init` (claude, codex or opencode), keeps the project cwd/environment and confirms the card is `in_progress` with an assignee before reporting success. This does not establish support for mixed-provider review; keep the doctor checks and independent-review requirements.",
+        `- If \`spawn_builder\` fails, report its error and resolve the cause before retrying. Only if the operator explicitly chooses manual startup, give this command for a new terminal in the project directory, with the real card id: \`${builderStartCommand(flavor, codexRolePath)}\`. After the operator says it is running, do the one post-launch \`get_task\` read the contract requires.`,
         "- Every role runs in its own session. Never act as two roles in one session.",
+        ...(flavor === "opencode" ? ["- OpenCode: brak wspieranego protokołu recenzji. Lokalny plugin `plugins/robisie-review-guard.js` odmawia wywołań `robisie_create_task` i `robisie_update_task` ze statusem `delivered` przed wysłaniem do MCP; taka próba nie zmienia karty. Wynik `task` z accept/VERIFIED, nazwa quality-officer-client, opis Agent ani JSON receiptu nie odblokowują przejścia. Hash receiptu nie dowodzi niezależnej sesji recenzenta."] : []),
         "- The credential comes from the `ROBISIE_KEY` environment variable. Never ask for it in chat and never write it into a card, a file or a command line.",
         "",
     ].join("\n");
@@ -112,7 +115,8 @@ export function renderClaudeAgent(role) {
 export function renderOpenCodeAgent(role) {
     // The Builder runs in its own session (`opencode run --agent …`); only the Quality Officer is a subagent.
     const mode = role.kind === "quality" ? "subagent" : "primary";
-    return `---\ndescription: ${JSON.stringify(role.description)}\nmode: ${mode}\n---\n${MANAGED_LINE}\n\n${adapterSection("opencode")}\n${role.body}`;
+    const permission = role.kind === "builder" ? "" : `permission:\n  edit: deny\n  bash: deny\n${role.kind === "quality" ? "  task: deny\n" : ""}`;
+    return `---\ndescription: ${JSON.stringify(role.description)}\nmode: ${mode}\n${permission}---\n${MANAGED_LINE}\n\n${adapterSection("opencode")}\n${role.body}`;
 }
 export function renderCodexRole(role, builderRolePath) {
     return `${MANAGED_LINE}\n\n# robisie role: ${role.name}\n\n> ${role.description}\n\n${adapterSection("codex", builderRolePath)}\n${role.body}`;

package/dist/seed-validation.d.ts

@@ -0,0 +1,28 @@
+export declare const SEED_FILES: {
+    readonly scope: "20-scope.md";
+    readonly spec: "25-spec.md";
+    readonly brief: "30-brief.md";
+};
+export declare const VALIDATE_USAGE = "u\u017Cycie: robisie-intent validate-seed <katalog-pakietu> [--repo katalog-repo] [--config robisie.config.json] [--efekt-dla <dope\u0142niacz>]";
+/** Domyślny odbiorca efektu w SCOPE (dopełniacz), gdy instancja nie poda własnego (roles.owner.genitive). */
+export declare const DEFAULT_EFFECT_FOR = "w\u0142a\u015Bciciela";
+/** Marker SCOPE „Efekt dla <odbiorca>” — to samo źródło dla szablonu Siewcy ({{WLASCICIEL}}) i walidatora. */
+export declare function effectMarker(effectFor?: string): string;
+export interface SeedValidation {
+    /** 0 = komplet, 2 = luka (jak w oryginale). */
+    exitCode: 0 | 2;
+    gaps: string[];
+    warnings: string[];
+    stdout: string;
+    stderr: string;
+}
+export interface SeedValidateOptions {
+    /** Repo, którego dotyczy write-set (w oryginale: repo zawierające skrypt). Domyślnie bieżący katalog. */
+    repo?: string;
+    /** Odbiorca efektu w markerze SCOPE „Efekt dla …” (dopełniacz; roles.owner.genitive). Oryginał miał go wbitego na sztywno. */
+    effectFor?: string;
+}
+/** Waliduje trzy artefakty siania (kolejność kanoniczna SCOPE → SPEC → BRIEF). */
+export declare function validateSeedFiles(scope: string, spec: string, brief: string, options?: SeedValidateOptions): SeedValidation;
+/** Waliduje katalog pakietu karty: 20-scope.md, 25-spec.md, 30-brief.md. */
+export declare function validateSeedPackage(directory: string, options?: SeedValidateOptions): SeedValidation;

package/dist/seed-validation.js

@@ -0,0 +1,294 @@
+// Walidator pakietu karty siewcy — odpowiednik docs/zrodla/walidator/seed-card-validate.sh w Node.
+// Te same kontrole, progi i komunikaty; bez bash/awk/grep. Jedyna różnica: odbiorca w markerze „Efekt dla …”
+// pochodzi z konfiguracji (effectFor), a nie jest wbity na sztywno. Git jest wołany bezpośrednio (execFileSync, bez powłoki)
+// tylko w kontroli §5, gdy SCOPE ma sekcję **Write-set.
+//
+// Świadoma granica (jak T1): sprawdza OBECNOŚĆ + FORMAT (nasze markery), NIE głębię/mądrość.
+import { execFileSync } from 'node:child_process';
+import { accessSync, constants, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+export const SEED_FILES = { scope: '20-scope.md', spec: '25-spec.md', brief: '30-brief.md' };
+export const VALIDATE_USAGE = 'użycie: robisie-intent validate-seed <katalog-pakietu> [--repo katalog-repo] [--config robisie.config.json] [--efekt-dla <dopełniacz>]';
+/** Domyślny odbiorca efektu w SCOPE (dopełniacz), gdy instancja nie poda własnego (roles.owner.genitive). */
+export const DEFAULT_EFFECT_FOR = 'właściciela';
+/** Marker SCOPE „Efekt dla <odbiorca>” — to samo źródło dla szablonu Siewcy ({{WLASCICIEL}}) i walidatora. */
+export function effectMarker(effectFor = DEFAULT_EFFECT_FOR) {
+    return `Efekt dla ${effectFor}`;
+}
+function readable(file) {
+    try {
+        if (!statSync(file).isFile())
+            return false;
+        accessSync(file, constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Linie pliku tak, jak widzi je grep/awk (bez pustego segmentu po końcowym \n). */
+function fileLines(file) {
+    const text = readFileSync(file, 'utf8');
+    const lines = text.split('\n');
+    if (lines.length && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+}
+function hasFixed(file, needle) {
+    return readable(file) && fileLines(file).some(line => line.includes(needle));
+}
+function hasRegex(file, pattern) {
+    return readable(file) && fileLines(file).some(line => pattern.test(line));
+}
+// [[:space:]] w lokalizacji C (mawk/grep bez UTF-8): spacja, \t, \n, \v, \f, \r.
+const SPACE = ' \\t\\n\\v\\f\\r';
+const BLANK_LINE = new RegExp(`^[${SPACE}]*$`);
+function git(root, args) {
+    try {
+        const stdout = execFileSync('git', ['-C', root, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], shell: false });
+        return { ok: true, stdout };
+    }
+    catch {
+        return { ok: false, stdout: '' };
+    }
+}
+function gitRoot(repo) {
+    const result = git(repo, ['rev-parse', '--show-toplevel']);
+    return result.ok ? result.stdout.replace(/\n+$/, '') : '';
+}
+/** Kolejność `sort -u` w lokalizacji C (po jednostkach kodu). */
+function sortUnique(values) {
+    return [...new Set(values)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+function writeSetPaths(scopeLines) {
+    const paths = [];
+    let inside = false;
+    for (const line of scopeLines) {
+        if (/^\*\*Write-set/.test(line)) {
+            inside = true;
+            continue;
+        }
+        if (inside && (/^\*\*/.test(line) || /^## /.test(line)))
+            break;
+        if (inside && /^- /.test(line)) {
+            for (const match of line.matchAll(/`[^`]+`/g)) {
+                const token = match[0].slice(1, -1);
+                if (!new RegExp(`[${SPACE}]`).test(token) && /[/.]/.test(token))
+                    paths.push(token);
+            }
+        }
+    }
+    return paths;
+}
+function outText(scopeLines) {
+    const out = [];
+    let inside = false;
+    for (const line of scopeLines) {
+        if (/^\*\*Świadomie POZA/.test(line)) {
+            inside = true;
+            continue;
+        }
+        if (inside && /^## /.test(line))
+            break;
+        if (inside)
+            out.push(line);
+    }
+    return out.join('\n');
+}
+function envTokens(lines) {
+    const tokens = [];
+    for (const line of lines) {
+        const envline = /(^|[^A-Za-z0-9_])\.?env([^A-Za-z0-9_]|$)|zmienn/.test(line.toLowerCase());
+        for (const match of line.matchAll(/[A-Z][A-Z0-9]*(_[A-Z0-9]+)+/g)) {
+            const t = match[0];
+            if (envline || line.includes('process.env.' + t) || line.includes(t + '='))
+                tokens.push(t);
+        }
+    }
+    return sortUnique(tokens);
+}
+function runtimeNames(lines, root) {
+    const kept = [];
+    const token = new RegExp(`\`[^\`]+\`|[^${SPACE}\`]+`, 'g');
+    const externalPath = /^\/([^/]+\/)*[A-Z][A-Z0-9_-]*\.(md|json|jsonl|log|txt)$/;
+    const notExternal = new RegExp(`\\/\\.\\.?\\/|[${SPACE}]\\/|\\/[${SPACE}]`);
+    for (const line of lines) {
+        const raws = [];
+        let last = 0;
+        for (const match of line.matchAll(token)) {
+            const raw = match[0];
+            const prefix = line.slice(last, match.index);
+            let path = raw;
+            if (/^`.*`$/.test(path))
+                path = path.slice(1, -1);
+            else
+                path = path.replace(/[.,;:)]*$/, '');
+            const external = !/`$/.test(prefix) && externalPath.test(path) && !notExternal.test(path) && !path.startsWith(root + '/');
+            if (!external)
+                raws.push(raw);
+            last = match.index + raw.length;
+        }
+        const joined = raws.map(raw => raw + ' ').join('');
+        // Alternatywa jsonl przed json: grep -o wybiera najdłuższe dopasowanie, JS — pierwsze.
+        for (const match of joined.matchAll(/`maszynista\/[A-Za-z0-9._-]+`|[A-Z][A-Z0-9_-]*\.(md|jsonl|json|log|txt)|`\.[a-z][a-z0-9-]+`/g)) {
+            kept.push(match[0].split('`').join(''));
+        }
+    }
+    return sortUnique(kept);
+}
+function doneWhenNumbers(scopeLines) {
+    const numbers = [];
+    let inside = false;
+    for (const line of scopeLines) {
+        if (new RegExp(`^##[${SPACE}]*done.?when`).test(line.toLowerCase())) {
+            inside = true;
+            continue;
+        }
+        if (inside && /^## /.test(line))
+            break;
+        const match = inside ? /^[0-9]+\./.exec(line) : null;
+        if (match)
+            numbers.push(match[0].slice(0, -1));
+    }
+    return numbers;
+}
+function mapNumbers(specLines) {
+    const numbers = [];
+    let inside = false;
+    const row = new RegExp(`^\\|[${SPACE}]*[0-9]+[${SPACE}]*\\|`);
+    const nonBlank = new RegExp(`[^${SPACE}]`);
+    for (const line of specLines) {
+        if (/[Mm]apa kryterium/.test(line))
+            inside = true;
+        if (!inside || !row.test(line))
+            continue;
+        const cols = line.split('|');
+        // awk: cols[3..5] = kolumny kryterium, rozwiązanie, sprawdzenie (JS: indeksy 2..4).
+        if ([2, 3, 4].some(i => !nonBlank.test(cols[i] ?? '')))
+            continue;
+        numbers.push(line.replace(new RegExp(`^\\|[${SPACE}]*`), '').replace(new RegExp(`[${SPACE}]*\\|[\\s\\S]*`), ''));
+    }
+    return numbers;
+}
+/** Waliduje trzy artefakty siania (kolejność kanoniczna SCOPE → SPEC → BRIEF). */
+export function validateSeedFiles(scope, spec, brief, options = {}) {
+    const gaps = [];
+    const warnings = [];
+    // ── 1. Istnienie trzech artefaktów (czytelny plik; katalog/nieczytelny = jawna luka) ──
+    if (!readable(scope))
+        gaps.push(`SCOPE nie istnieje lub nie jest czytelnym plikiem: ${scope}`);
+    if (!readable(brief))
+        gaps.push(`BRIEF nie istnieje lub nie jest czytelnym plikiem: ${brief}`);
+    if (!readable(spec))
+        gaps.push(`SPEC nie istnieje lub nie jest czytelnym plikiem: ${spec}`);
+    // ── 2. BRIEF — kanon MB ──
+    if (readable(brief)) {
+        if (!hasFixed(brief, 'scopeRef:'))
+            gaps.push("BRIEF: brak 'scopeRef:' (brama T1 rozwija scopeRef → SCOPE)");
+        if (!hasFixed(brief, 'designRef:'))
+            gaps.push("BRIEF: brak 'designRef:' (brama T1 rozwija designRef → SPEC)");
+        const markers = ['specialist:', 'acceptance_criteria_wiring:', '## Skill (REQUIRED)', '## Done When', 'Example Mapping'];
+        const miss = markers.filter(marker => !hasFixed(brief, marker));
+        const hits = markers.length - miss.length;
+        if (hits < 3)
+            gaps.push(`BRIEF: za mało markerów kanonu MB (${hits}/5, wymagane ≥3) — brakuje: ${miss.join(' ')}`);
+    }
+    // ── 3. SCOPE — Wzór scope (≥4 z 6) ──
+    if (readable(scope)) {
+        const checks = [
+            ['Cel', hasFixed(scope, 'Cel')],
+            [effectMarker(options.effectFor), hasFixed(scope, effectMarker(options.effectFor))],
+            // „Granice + lane:” liczone jako jeden marker; 'lane[: =]' by NIE łapać „Planer”.
+            ['Granice/lane', hasRegex(scope, new RegExp(`lane[${SPACE}]*[:=]`, 'i')) || hasFixed(scope, 'Granice')],
+            ['Done-When', hasRegex(scope, /Done.?When/i)],
+            ['specialist', hasRegex(scope, /specialist/i)],
+            // servesGoal = SŁOWO 'servesGoal', nie samo '#N'.
+            ['servesGoal', hasFixed(scope, 'servesGoal')],
+        ];
+        const miss = checks.filter(([, hit]) => !hit).map(([name]) => name);
+        const hits = checks.length - miss.length;
+        if (hits < 4)
+            gaps.push(`SCOPE: za mało markerów Wzoru scope (${hits}/6, wymagane ≥4) — brakuje: ${miss.join(' ')}`);
+    }
+    // ── 4. SPEC — istnienie + niepustość (≥15 linii treści) ──
+    if (readable(spec)) {
+        const specLines = fileLines(spec).filter(line => !BLANK_LINE.test(line)).length;
+        if (specLines < 15)
+            gaps.push(`SPEC: za krótki (${specLines} linii treści, wymagane ≥15) — design rationale, nie zaślepka`);
+    }
+    // ── 5. Spójność write-setu z treścią SPEC/BRIEF; to NIE marker T1. ──
+    if (readable(scope) && readable(spec) && readable(brief)) {
+        const scopeLines = fileLines(scope);
+        if (scopeLines.some(line => /^\*\*Write-set/.test(line))) {
+            const root = gitRoot(resolve(options.repo ?? '.'));
+            if (!root || !readable(join(root, '.env.example')) || !git(root, ['ls-files']).ok) {
+                gaps.push('write-set: nie mogę odczytać repo lub .env.example — sprawdź git i repo');
+            }
+            else {
+                const ws = writeSetPaths(scopeLines);
+                const inWs = (path) => ws.includes(path);
+                const out = outText(scopeLines);
+                if (!ws.length)
+                    gaps.push('write-set: sekcja Write-set bez ścieżek plikowych — wpisz ścieżki w backtickach');
+                const contentLines = [...fileLines(spec), ...fileLines(brief)];
+                const envExample = fileLines(join(root, '.env.example'));
+                for (const token of envTokens(contentLines)) {
+                    const inExample = envExample.some(line => new RegExp(`^#? *${token}(=|$)`).test(line));
+                    if (!inWs('.env.example') && !inExample
+                        && !git(root, ['grep', '-qF', '-e', token, '--', '.', ':!.env.example', ':!docs', ':!*.md']).ok) {
+                        gaps.push(`write-set: nowa zmienna env ${token} nie ma wpisu w .env.example — dopisz .env.example do write-setu`);
+                    }
+                }
+                for (const name of runtimeNames(contentLines, root)) {
+                    const [path, bare] = name.startsWith('maszynista/') ? [name, ''] : [`maszynista/${name}`, name];
+                    if (inWs(path))
+                        continue;
+                    if (git(root, ['ls-files', '--error-unmatch', '--', path]).ok)
+                        continue;
+                    if (git(root, ['check-ignore', '-q', '--', path]).ok)
+                        continue;
+                    if (bare && git(root, ['ls-files', '--', `*/${bare}`, bare]).stdout !== '')
+                        continue;
+                    if (!inWs('.gitignore'))
+                        gaps.push(`write-set: nowy plik runtime ${path} nie jest ignorowany przez git — dopisz .gitignore do write-setu`);
+                }
+                if (contentLines.some(line => /`[^`]*(State|parseState)[^`]*`/.test(line)) && !out.includes('parseState') && !inWs('maszynista/lib.ts')) {
+                    gaps.push('write-set: stan taktu (State/parseState) zmieniany bez maszynista/lib.ts — parser gubi nowe pola; dopisz maszynista/lib.ts albo wymień parseState w OUT');
+                }
+            }
+        }
+    }
+    // ── 6. Mapa kryterium → rozwiązanie → sprawdzenie ──
+    if (readable(scope) && readable(spec)) {
+        const dw = doneWhenNumbers(fileLines(scope));
+        if (dw.length) {
+            const map = mapNumbers(fileLines(spec));
+            const missing = dw.filter(n => !map.includes(n));
+            if (missing.length) {
+                const list = missing.join(',');
+                if (hasFixed(scope, 'reksio/propozycja')) {
+                    gaps.push(`mapa: brak wiersza mapy kryterium→rozwiązanie→sprawdzenie dla done_when #${list} (SPEC.md, sekcja 'Mapa kryterium')`);
+                }
+                else {
+                    warnings.push(`⚠️ mapa: brak wiersza mapy dla done_when #${list} (SCOPE bez markera reksio/propozycja — ostrzeżenie, nie blokuje)`);
+                }
+            }
+        }
+    }
+    // ── Werdykt ──
+    const warningText = warnings.map(w => w + '\n').join('');
+    if (gaps.length) {
+        const stderr = warningText + [
+            '🐾 STOP — kroku 4 (sekretarz) NIE odpalać: komplet artefaktów niespełniony.',
+            `Braki (${gaps.length}):`,
+            ...gaps.map(g => `  ✗ ${g}`),
+            'Uzupełnij brakujące artefakty/markery (kroki 2-3), potem ponów walidator.',
+        ].map(line => line + '\n').join('');
+        return { exitCode: 2, gaps, warnings, stdout: '', stderr };
+    }
+    return { exitCode: 0, gaps, warnings, stdout: '✓ komplet 3 artefaktów + markery NASZYCH szablonów — gotowe na sekretarza (krok 4).\n', stderr: warningText };
+}
+/** Waliduje katalog pakietu karty: 20-scope.md, 25-spec.md, 30-brief.md. */
+export function validateSeedPackage(directory, options = {}) {
+    return validateSeedFiles(join(directory, SEED_FILES.scope), join(directory, SEED_FILES.spec), join(directory, SEED_FILES.brief), options);
+}

package/dist/selection-result.d.ts

@@ -0,0 +1,44 @@
+export type Goal = {
+    canon: string;
+};
+export type CardQualification = {
+    effort: "low" | "medium" | "high" | null;
+    trackName: string | null;
+    reasons: string[];
+};
+export type QualifyCard = (card: {
+    id: string;
+    title: string;
+    details: {
+        scope: string[];
+    };
+}) => CardQualification;
+export type Proposal = {
+    title: string;
+    servesGoal: string;
+    servesNS: string | null;
+    ns_proof: string;
+    goal_ref: string;
+    why_now: string;
+    done_when: string[];
+    scope: string[];
+    out: string[];
+    codex_effort: NonNullable<CardQualification["effort"]>;
+    proposed_track: NonNullable<CardQualification["trackName"]>;
+    qualification: CardQualification;
+};
+export declare function stripFence(text: string): string;
+export declare function extractJsonObject(raw: string): string | null;
+export type ProposalParseResult = {
+    ok: Proposal[];
+    rejected: Array<{
+        title: string;
+        reason: string;
+    }>;
+    warnings: string[];
+    rawCount: number;
+    prose: string;
+    empty_reason?: string;
+    error?: string;
+};
+export declare function parseProposals(raw: string, goals: Goal[], nsIds: string[] | undefined, qualifyCard: QualifyCard): ProposalParseResult;