robisie 0.1.0 → 0.1.1

package/dist/opencode-result.d.ts

@@ -0,0 +1,19 @@
+export type OpenCodeTokenUsage = Readonly<{
+    input?: number;
+    output?: number;
+    reasoning?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}>;
+export declare function parseOpenCodeStream(raw: string, model: string): {
+    sessionId: string;
+    messageId: string;
+    report: string;
+    costUsd?: number;
+    usage?: OpenCodeTokenUsage;
+};
+export declare function bindOpenCodeExport(raw: string, stream: {
+    sessionId: string;
+    messageId: string;
+    report: string;
+}, model: string): void;

package/dist/opencode-result.js

@@ -0,0 +1,136 @@
+const PROVIDER = "opencode-go";
+const REPORT_MARKER = "### RAPORT MASZYNISTY";
+const SAFE_STREAM_ID = /^(?:ses|msg)_[A-Za-z0-9]+$/;
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function countMarker(text) {
+    return text.split(REPORT_MARKER).length - 1;
+}
+export function parseOpenCodeStream(raw, model) {
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim());
+    if (lines.length === 0)
+        throw new Error("OpenCode stream is empty");
+    let sessionId = null;
+    const textByMessage = new Map();
+    const seenModels = new Set(), seenProviders = new Set();
+    const costs = [];
+    const usage = {};
+    let usageObserved = false;
+    let lastTextMessageId = null;
+    for (const line of lines) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            throw new Error("OpenCode stream contains malformed JSON");
+        }
+        const event = record(parsed), part = record(event?.part);
+        if (!event || !part || typeof event.timestamp !== "number" || !Number.isFinite(event.timestamp)
+            || typeof event.sessionID !== "string" || !SAFE_STREAM_ID.test(event.sessionID))
+            throw new Error("OpenCode stream envelope is malformed");
+        if (sessionId !== null && event.sessionID !== sessionId)
+            throw new Error("OpenCode stream mixes sessions");
+        sessionId = event.sessionID;
+        const type = event.type, partType = part.type;
+        if (!["step_start", "reasoning", "tool_use", "text", "step_finish"].includes(type)) {
+            throw new Error(`OpenCode stream event is unsupported: ${String(type)}`);
+        }
+        const messageId = part.messageID;
+        if (messageId !== undefined && (typeof messageId !== "string" || !SAFE_STREAM_ID.test(messageId)))
+            throw new Error("OpenCode stream message identity is malformed");
+        if (type === "step_start") {
+            if (partType !== "step-start")
+                throw new Error("OpenCode step_start is malformed");
+            if (typeof part.model === "string" && part.model.trim())
+                seenModels.add(part.model);
+            if (typeof part.provider === "string" && part.provider.trim())
+                seenProviders.add(part.provider);
+        }
+        else if (type === "text") {
+            if (partType !== "text" || typeof messageId !== "string" || typeof part.text !== "string")
+                throw new Error("OpenCode text event is malformed");
+            const chunks = textByMessage.get(messageId) ?? [];
+            chunks.push(part.text);
+            textByMessage.set(messageId, chunks);
+            lastTextMessageId = messageId;
+        }
+        else if (type === "reasoning" && partType !== "reasoning")
+            throw new Error("OpenCode reasoning event is malformed");
+        else if (type === "step_finish") {
+            if (partType !== "step-finish")
+                throw new Error("OpenCode step_finish is malformed");
+            if (part.cost !== undefined) {
+                if (typeof part.cost !== "number" || !Number.isFinite(part.cost) || part.cost < 0)
+                    throw new Error("OpenCode stream cost is malformed");
+                costs.push(part.cost);
+            }
+            if (part.tokens !== undefined) {
+                const tokens = record(part.tokens), cache = record(tokens?.cache);
+                if (!tokens)
+                    throw new Error("OpenCode stream usage is malformed");
+                const values = [
+                    ["input", tokens.input], ["output", tokens.output], ["reasoning", tokens.reasoning],
+                    ["cacheRead", cache?.read], ["cacheWrite", cache?.write],
+                ];
+                for (const [key, value] of values) {
+                    if (value === undefined)
+                        continue;
+                    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+                        throw new Error("OpenCode stream usage is malformed");
+                    usage[key] = (usage[key] ?? 0) + value;
+                    usageObserved = true;
+                }
+            }
+        }
+    }
+    const reports = [...textByMessage].map(([messageId, chunks]) => ({ messageId, report: chunks.join("") }))
+        .filter(({ report }) => countMarker(report) === 1);
+    if (!sessionId || reports.length !== 1 || reports[0]?.messageId !== lastTextMessageId) {
+        throw new Error("OpenCode stream does not contain exactly one final report");
+    }
+    for (const observed of seenModels) {
+        if (observed !== model && observed !== `${PROVIDER}/${model}`)
+            throw new Error("OpenCode stream model does not match the selected model");
+    }
+    for (const observed of seenProviders)
+        if (observed !== PROVIDER)
+            throw new Error("OpenCode stream provider does not match the Go plan");
+    return { sessionId, ...reports[0], ...(costs.length ? { costUsd: costs.reduce((sum, cost) => sum + cost, 0) } : {}),
+        ...(usageObserved ? { usage } : {}) };
+}
+export function bindOpenCodeExport(raw, stream, model) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("OpenCode export is malformed JSON");
+    }
+    const root = record(parsed), info = record(root?.info);
+    if (!root || info?.id !== stream.sessionId || !Array.isArray(root.messages))
+        throw new Error("OpenCode export session does not match stream");
+    const matches = root.messages.map(record).filter((message) => message?.type === "assistant" && message.id === stream.messageId);
+    if (matches.length !== 1)
+        throw new Error("OpenCode export message does not match stream");
+    const assistant = matches[0], identity = record(assistant.model);
+    if (identity?.id !== model || identity.providerID !== PROVIDER || assistant.finish !== "stop" || assistant.rawFinish !== "stop") {
+        throw new Error("OpenCode export terminal identity is malformed");
+    }
+    if (assistant.error !== undefined
+        || (assistant.modelID !== undefined && assistant.modelID !== identity.id)
+        || (assistant.providerID !== undefined && assistant.providerID !== identity.providerID)) {
+        throw new Error("OpenCode export contains conflicting terminal identity");
+    }
+    if (!Array.isArray(assistant.content))
+        throw new Error("OpenCode export content is malformed");
+    const textParts = assistant.content.map(record).filter((part) => part?.type === "text");
+    if (textParts.length !== 1 || textParts.some((part) => typeof part?.text !== "string"))
+        throw new Error("OpenCode export report is malformed");
+    const report = textParts.map((part) => String(part?.text)).join("");
+    if (countMarker(report) !== 1 || report !== stream.report)
+        throw new Error("OpenCode export report does not match stream");
+}

package/dist/opencode-review-guard.d.ts

@@ -0,0 +1 @@
+export declare const OPENCODE_REVIEW_GUARD: string;

package/dist/opencode-review-guard.js

@@ -0,0 +1,19 @@
+import { FILE_MARK } from "./constants.js";
+// Keep this function self-contained: its compiled JS is the installed plugin.
+async function robisieReviewGuard() {
+    return {
+        "tool.execute.before": async (input, output) => {
+            if (typeof input !== "object" || input === null || !("tool" in input))
+                return;
+            if (input.tool !== "robisie_create_task" && input.tool !== "robisie_update_task")
+                return;
+            if (typeof output !== "object" || output === null || !("args" in output))
+                return;
+            const args = output.args;
+            if (typeof args === "object" && args !== null && "status" in args && args.status === "delivered") {
+                throw new Error("Brak wspieranego protokołu recenzji w OpenCode. Ta próba nie zmieniła karty.");
+            }
+        },
+    };
+}
+export const OPENCODE_REVIEW_GUARD = `// ${FILE_MARK}\nexport const RobisieReviewGuard = ${robisieReviewGuard.toString()};\n`;

package/dist/opencode-session-export.d.ts

@@ -0,0 +1,5 @@
+import { type SpawnSyncOptionsWithStringEncoding, type SpawnSyncReturns } from "node:child_process";
+/** OpenCode may exit before pipe stdout drains; a regular file preserves the export. */
+export declare function exportOpenCodeSessionFile(binary: string, session: string, options: SpawnSyncOptionsWithStringEncoding & {
+    maxBuffer: number;
+}): SpawnSyncReturns<string>;

package/dist/opencode-session-export.js

@@ -0,0 +1,28 @@
+import { spawnSync } from "node:child_process";
+import { closeSync, mkdtempSync, openSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** OpenCode may exit before pipe stdout drains; a regular file preserves the export. */
+export function exportOpenCodeSessionFile(binary, session, options) {
+    const dir = mkdtempSync(join(tmpdir(), "opencode-export-"));
+    let fd;
+    try {
+        const file = join(dir, "session.json");
+        fd = openSync(file, "w", 0o600);
+        const result = spawnSync(binary, ["session", "export", session], { ...options, shell: false, stdio: ["ignore", fd, "pipe"] });
+        if (statSync(file).size > options.maxBuffer) {
+            return { ...result, status: null, stdout: "", error: result.error ?? Object.assign(new Error(`spawnSync ${binary} ENOBUFS: session export exceeds ${options.maxBuffer} bytes`), { code: "ENOBUFS" }) };
+        }
+        return { ...result, stdout: readFileSync(file, "utf8") };
+    }
+    finally {
+        // IO errors propagate to the caller's existing process-error handling.
+        try {
+            if (fd !== undefined)
+                closeSync(fd);
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/outcome-moves.d.ts

@@ -0,0 +1,15 @@
+import { type WorkerOutcome, type ReviewVerdict } from "./role-results.js";
+/** Mapuje wynik Workera na ruch na tablicy. */
+export declare function decideBoardMove(outcome: WorkerOutcome, attempts: number, maxAttempts?: number): {
+    status: "in_review";
+    note: string;
+} | {
+    status: "blocked";
+    note: string;
+} | {
+    status: "retry";
+    note: string;
+};
+export declare const MAX_REVIEW_ROUNDS = 3;
+/** reviewRound = indeks od zera; unavailable obejmuje bieżącą próbę. Grant R3 weryfikuje i trwale konsumuje caller. */
+export declare function decideReviewMove(verdict: ReviewVerdict, reviewRound: number, unavailable?: number, verifiedR3Grant?: boolean): "land" | "repair" | "blocked" | "retry-review";

package/dist/outcome-moves.js

@@ -0,0 +1,39 @@
+import { plainMarkers } from "./role-results.js";
+/** Mapuje wynik Workera na ruch na tablicy. */
+export function decideBoardMove(outcome, attempts, maxAttempts = 3) {
+    /** Powód: tekst po „CZEGO NIE ZROBIONO I DLACZEGO:” w tej samej linii, inaczej pierwsza niepusta linia niżej. */
+    const reasonOf = (status) => {
+        const lines = plainMarkers(outcome.report).split(/\r?\n/).map((line) => line.trim());
+        const statusLine = lines.findIndex((line) => new RegExp(`^[-*]?\\s*STATUS:\\s*${status}\\b`).test(line));
+        const header = /^[-*]?\s*CZEGO NIE ZROBIONO I DLACZEGO:\s*(.*)$/;
+        const field = lines.findIndex((line, index) => index > statusLine && header.test(line));
+        const reason = (field >= 0 ? header.exec(lines[field])?.[1] : "")
+            || lines.slice((field >= 0 ? field : statusLine) + 1).find(Boolean)?.replace(/^[-*]\s*/, "") || "brak podanego powodu";
+        return Array.from(reason).slice(0, 200).join("");
+    };
+    switch (outcome.status) {
+        case "WORKER_FINISHED":
+        case "ALREADY_DONE":
+            return { status: "in_review", note: `${outcome.status} — dowód w details.maszynista` };
+        case "NEEDS_HUMAN":
+            return { status: "blocked", note: `worker: WYMAGA CZŁOWIEKA — ${reasonOf("NEEDS_HUMAN")}` };
+        case "ACTIONABLE_BLOCKER":
+            return { status: "blocked", note: `worker: ACTIONABLE_BLOCKER — ${reasonOf("ACTIONABLE_BLOCKER")}` };
+        case "FAILED":
+        case "UNKNOWN":
+        default:
+            if (attempts < maxAttempts)
+                return { status: "retry", note: `próba ${attempts}/${maxAttempts} nieudana (${outcome.status})` };
+            return { status: "blocked", note: `${maxAttempts} próby nieudane (${outcome.status}) — blokada techniczna, do CR/Reksia` };
+    }
+}
+export const MAX_REVIEW_ROUNDS = 3;
+/** reviewRound = indeks od zera; unavailable obejmuje bieżącą próbę. Grant R3 weryfikuje i trwale konsumuje caller. */
+export function decideReviewMove(verdict, reviewRound, unavailable = 0, verifiedR3Grant = false) {
+    if (verdict === "PASS")
+        return "land";
+    if (verdict === "FAIL")
+        return reviewRound < MAX_REVIEW_ROUNDS - 1
+            || verifiedR3Grant === true && reviewRound === MAX_REVIEW_ROUNDS - 1 ? "repair" : "blocked";
+    return unavailable >= 3 ? "blocked" : "retry-review";
+}

package/dist/planer-client.d.ts

@@ -0,0 +1,214 @@
+import { z } from "zod";
+/** No environment, filesystem, DB or Keychain reads. Pass Ctx.origin/fetch and ROBISIE_KEY explicitly. */
+export type PlanerClientConfig = ({
+    origin: string;
+    endpoint?: never;
+} | {
+    endpoint: string;
+    origin?: never;
+}) & {
+    token: string;
+    fetch?: typeof fetch;
+    deadlineMs?: number;
+};
+type Operation = "connect" | "close" | "list_projects" | "list_tracks" | "list_tasks" | "get_task" | "reserve_task" | "update_task" | "append_detail" | "close_decision_matter" | "get_review_snapshot" | "accept_review" | "create_track" | "create_task";
+type Failure = "INVALID_CONFIG" | "INVALID_ARGUMENT" | "NOT_CONNECTED" | "CLOSED" | "CONTRACT_VERSION" | "INVALID_RESPONSE" | "DETAILS_READ_ERROR" | "TOOL_ERROR" | "UNAUTHORIZED" | "FORBIDDEN" | "RATE_LIMITED" | "HTTP_ERROR" | "RPC_ERROR" | "TRANSPORT_ERROR" | "TIMEOUT";
+/** Fixed reason only. In particular, never attach SDK message, cause, raw body or caller arguments. */
+export declare class PlanerClientError extends Error {
+    readonly code: Failure;
+    readonly operation: Operation;
+    /** A write may have reached the server: caller must read/decide before another write. */
+    readonly uncertain: boolean;
+    constructor(code: Failure, operation: Operation, 
+    /** A write may have reached the server: caller must read/decide before another write. */
+    uncertain?: boolean, diagnostic?: {
+        plannerCode?: string;
+        requestId?: string;
+    });
+    readonly plannerCode?: string;
+    readonly requestId?: string;
+}
+declare const jsonObject: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+declare const projectSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    name: z.ZodString;
+    slug: z.ZodString;
+}, z.core.$strip>;
+declare const trackSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    projectId: z.ZodUUID;
+    name: z.ZodString;
+    position: z.ZodNumber;
+}, z.core.$strip>;
+declare const taskSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    projectId: z.ZodUUID;
+    trackId: z.ZodUUID;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        in_review: "in_review";
+        in_progress: "in_progress";
+        delivered: "delivered";
+        blocked: "blocked";
+        done: "done";
+        draft: "draft";
+    }>;
+    assignee: z.ZodNullable<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodUUID>;
+}, z.core.$strip>;
+declare const echoSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        in_review: "in_review";
+        in_progress: "in_progress";
+        delivered: "delivered";
+        blocked: "blocked";
+        done: "done";
+        draft: "draft";
+    }>;
+    trackId: z.ZodUUID;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+declare const createTaskSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        in_review: "in_review";
+        in_progress: "in_progress";
+        delivered: "delivered";
+        blocked: "blocked";
+        done: "done";
+        draft: "draft";
+    }>;
+    trackId: z.ZodUUID;
+    updatedAt: z.ZodISODateTime;
+    similarOpenCards: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        title: z.ZodString;
+        track: z.ZodString;
+        status: z.ZodEnum<{
+            ready: "ready";
+            in_review: "in_review";
+            in_progress: "in_progress";
+            delivered: "delivered";
+            blocked: "blocked";
+            done: "done";
+            draft: "draft";
+        }>;
+        score: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const reviewSnapshotSchema: z.ZodObject<{
+    cardId: z.ZodUUID;
+    projectId: z.ZodUUID;
+    submissionId: z.ZodUUID;
+    snapshot: z.ZodString;
+    label: z.ZodLiteral<"recenzja innym kluczem; dostawca deklarowany">;
+}, z.core.$strip>;
+declare const acceptReviewInput: z.ZodObject<{
+    id: z.ZodUUID;
+    cardId: z.ZodUUID;
+    projectId: z.ZodUUID;
+    submissionId: z.ZodUUID;
+    snapshot: z.ZodString;
+    providerDeclared: z.ZodString;
+}, z.core.$strict>;
+export type ReviewSnapshot = z.infer<typeof reviewSnapshotSchema>;
+export type AcceptReviewInput = z.infer<typeof acceptReviewInput>;
+declare const reservationSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    status: z.ZodEnum<{
+        ready: "ready";
+        in_review: "in_review";
+        in_progress: "in_progress";
+        delivered: "delivered";
+        blocked: "blocked";
+        done: "done";
+        draft: "draft";
+    }>;
+    assignee: z.ZodNullable<z.ZodString>;
+    trackId: z.ZodUUID;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+declare const appendSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        in_review: "in_review";
+        in_progress: "in_progress";
+        delivered: "delivered";
+        blocked: "blocked";
+        done: "done";
+        draft: "draft";
+    }>;
+    trackId: z.ZodUUID;
+    updatedAt: z.ZodISODateTime;
+    appendedKeys: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const closeSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        CLOSED: "CLOSED";
+        ALREADY_CLOSED: "ALREADY_CLOSED";
+        CONFLICT: "CONFLICT";
+        NOT_APPLIED: "NOT_APPLIED";
+    }>;
+    cardId: z.ZodUUID;
+    matterId: z.ZodString;
+    matter: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strip>;
+export type PlanerTask = z.infer<typeof taskSchema> & {
+    details?: z.infer<typeof jsonObject> | null;
+    availableDetailsKeys?: string[] | null;
+};
+export type PlanerTaskWithReadiness = PlanerTask & {
+    depsReady: boolean;
+};
+export type AppendDetailResult = {
+    write: z.infer<typeof appendSchema>;
+    /** Write confirmation survives a failed readback; never repeat the append to repair a read. */
+    readback: {
+        ok: true;
+        task: PlanerTask | null;
+    } | {
+        ok: false;
+        error: PlanerClientError;
+    };
+};
+export type CloseDecisionResult = Omit<z.infer<typeof closeSchema>, "matter"> & {
+    isError: boolean;
+};
+/** Existing MCP operations only. No auto-connect, retry, CAS emulation or runtime cutover. */
+export declare class PlanerClient {
+    #private;
+    constructor(config: unknown);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    listProjects(args?: unknown): Promise<z.infer<typeof projectSchema>[]>;
+    listTracks(args: unknown): Promise<z.infer<typeof trackSchema>[]>;
+    createTrack(args: unknown): Promise<z.infer<typeof trackSchema>>;
+    createTask(args: unknown): Promise<z.infer<typeof createTaskSchema>>;
+    listTasks(args: unknown): Promise<PlanerTaskWithReadiness[]>;
+    getTask(args: unknown): Promise<PlanerTask | null>;
+    reserveTask(args: unknown): Promise<z.infer<typeof reservationSchema>>;
+    /** Server snapshot of an in_review card; does not confirm enforced policy or code/model provenance.
+     * Rejects malformed/mismatched responses with INVALID_RESPONSE, uncertain=false. */
+    getReviewSnapshot(args: unknown): Promise<ReviewSnapshot>;
+    /** Server owns policy, authenticated actor and atomic receipt/delivered write. providerDeclared is
+     * only a declaration, not proof of model execution. No retry, update_task fallback or snapshot refresh.
+     * Strict input: matching id/cardId, UUIDs, lowercase 64-hex snapshot, trimmed 1–200 character declaration.
+     * Local validation fails with INVALID_ARGUMENT/uncertain=false; failures after sending are uncertain.
+     * After an uncertain write, caller must explicitly getTask({id, include:['review_receipt']}) and decide. */
+    acceptReview(args: unknown): Promise<z.infer<typeof echoSchema>>;
+    /** For draft promotion, pass {status:'ready', expected:{status:'draft'}}. Server owns CAS/permissions. */
+    updateTask(args: unknown): Promise<z.infer<typeof echoSchema>>;
+    /** Flat server merge; null is literal. No deep merge, chunking, append guard or implicit retry. */
+    appendDetail(args: unknown): Promise<AppendDetailResult>;
+    /** full/owner_validator authority stays on the server. Non-CLOSED outcomes retain isError. */
+    closeDecisionMatter(args: unknown): Promise<CloseDecisionResult>;
+}
+export {};