@genkaku/protocol 0.0.0-stage → 0.1.0

package/dist/lp.js

@@ -0,0 +1,116 @@
+// GENKAKU: LP-JSON wire primitives (protocol v0).
+// 4-byte big-endian length prefix + UTF-8 JSON. Frame codec is streamable:
+// sessions START before the peer finishes writing (tokens keep flowing after
+// the open envelope), so reads must increment — never drain-to-EOS.
+// A sink may only be attached ONCE per libp2p stream; all writes to one stream
+// go through a WriteQueue whose async generator never ends until .end().
+export function lpEncode(obj) {
+    const body = new TextEncoder().encode(JSON.stringify(obj) + '\n');
+    const head = new Uint8Array(4);
+    new DataView(head.buffer).setUint32(0, body.byteLength);
+    const out = new Uint8Array(head.length + body.length);
+    out.set(head);
+    out.set(body, head.length);
+    return out;
+}
+function toU8(c) {
+    if (c instanceof Uint8Array) {
+        return c;
+    }
+    return c.subarray();
+}
+function parseFrames(buf) {
+    const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const frames = [];
+    let p = 0;
+    while (p + 4 <= buf.length) {
+        const len = dv.getUint32(p);
+        if (len === 0 || p + 4 + len > buf.length) {
+            break;
+        }
+        try {
+            frames.push(JSON.parse(new TextDecoder().decode(buf.subarray(p + 4, p + 4 + len))));
+        }
+        catch { /* tolerate */ }
+        p += 4 + len;
+    }
+    return { frames, consumed: p };
+}
+/** Parse every COMPLETE frame in a byte blob (tests / whole-stream reads). */
+export function lpFrames(chunks) {
+    const parts = [];
+    let total = 0;
+    for (const c of chunks) {
+        const u = toU8(c);
+        parts.push(u);
+        total += u.length;
+    }
+    const buf = new Uint8Array(total);
+    let off = 0;
+    for (const u of parts) {
+        buf.set(u, off);
+        off += u.length;
+    }
+    return parseFrames(buf).frames;
+}
+/**
+ * Incremental frame reader — feeds whatever bytes arrive and pops complete
+ * frames WITHOUT waiting for stream end.
+ */
+export class FrameReader {
+    buf = new Uint8Array(0);
+    push(chunk) {
+        const u = toU8(chunk);
+        const merged = new Uint8Array(this.buf.length + u.length);
+        merged.set(this.buf);
+        merged.set(u, this.buf.length);
+        this.buf = merged;
+    }
+    /** next complete frame, or undefined while the current one is still partial */
+    next() {
+        const { frames, consumed } = parseFrames(this.buf);
+        if (frames.length === 0) {
+            return undefined;
+        }
+        this.buf = this.buf.subarray(consumed);
+        return frames[0];
+    }
+}
+/**
+ * One durable write side per stream: `sink(queue.source())` once, then push
+ * frames as they happen; the write half stays open until .end().
+ */
+export class WriteQueue {
+    items = [];
+    waiters = [];
+    /** end() has been called — readers will see EOF after draining the items */
+    ended = false;
+    push(b) {
+        if (this.ended) {
+            return;
+        }
+        this.items.push(b);
+        this.drain();
+    }
+    end() {
+        this.ended = true;
+        this.drain();
+    }
+    drain() {
+        for (const w of this.waiters.splice(0)) {
+            w();
+        }
+    }
+    async *source() {
+        while (true) {
+            while (this.items.length > 0) {
+                yield this.items.shift();
+            }
+            if (this.ended) {
+                return;
+            }
+            await new Promise(resolve => this.waiters.push(resolve));
+        }
+    }
+}
+//# sourceMappingURL=lp.js.map

package/dist/modeManager.d.ts

@@ -0,0 +1,30 @@
+export type RoleMode = 'user' | 'localPlusSharing' | 'workerDedicated';
+export type ModeState = {
+    mode: RoleMode;
+    /** a live remote session consumes another peer's worker this instant */
+    remoteUserActive: boolean;
+    /** this machine exposes /genkaku/* worker protocols on its libp2p node */
+    sharingActive: boolean;
+};
+export declare class ModeError extends Error {
+    readonly code: string;
+    constructor(msg: string, code: string);
+}
+export declare class ModeManager {
+    private readonly onTransition?;
+    private state;
+    constructor(onTransition?: ((from: RoleMode, to: RoleMode) => void) | undefined);
+    current(): Readonly<ModeState>;
+    /** Enter a role. `remoteUserActive` hints whether a live remote session should
+     *  carry over (only meaningful user→user). */
+    switch(to: RoleMode, opts?: {
+        remoteUserActive?: boolean;
+    }): ModeState;
+    /** Sidecar calls at transport start (user mode only; D-block is enforced here). */
+    beginRemoteSession(): void;
+    endRemoteSession(): void;
+    /** Sidecar guard before installing /genkaku/* protocol handlers. */
+    installWorkerListeners(): 'installed' | 'already';
+    removeWorkerListeners(): void;
+}
+//# sourceMappingURL=modeManager.d.ts.map

package/dist/modeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeManager.d.ts","sourceRoot":"","sources":["../src/modeManager.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,kBAAkB,GAAG,iBAAiB,CAAA;AAEtE,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,QAAQ,CAAA;IACd,wEAAwE;IACxE,gBAAgB,EAAE,OAAO,CAAA;IACzB,0EAA0E;IAC1E,aAAa,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,qBAAa,SAAU,SAAQ,KAAK;aACO,IAAI,EAAE,MAAM;gBAAzC,GAAG,EAAE,MAAM,EAAkB,IAAI,EAAE,MAAM;CAGtD;AAED,qBAAa,WAAW;IAGV,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IAF1C,OAAO,CAAC,KAAK,CAAW;gBAEK,YAAY,CAAC,GAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,KAAK,IAAI,aAAA;IAIlF,OAAO,IAAI,QAAQ,CAAC,SAAS,CAAC;IAI9B;kDAC8C;IAC9C,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,GAAE;QAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,SAAS;IAkB1E,mFAAmF;IACnF,kBAAkB,IAAI,IAAI;IAY1B,gBAAgB,IAAI,IAAI;IAIxB,oEAAoE;IACpE,sBAAsB,IAAI,WAAW,GAAG,SAAS;IAgBjD,qBAAqB,IAAI,IAAI;CAO9B"}

package/dist/modeManager.js

@@ -0,0 +1,81 @@
+// GENKAKU: role mode manager — the D-block enforcement lives HERE and in the
+// sidecar (never both a remote-user dialer and a worker listener on one machine).
+// Spec: docs/genkaku/P4-ADAPTATION.md §2; user-locked rule 2026-11-06.
+//
+// Semantics:
+//   · "remote session"  = this machine CONSUMES someone else's worker stream
+//   · "sharing"         = this machine SERVES its local LLM over libp2p
+//   · A user            : may hold remote sessions, never shares
+//   · B localPlusSharing: owners use their LOCAL model + share idle capacity
+//        ("local use" is not a remote session — no counterparty, no metering)
+//   · C workerDedicated : pure serving
+//   · D                 : remote-consumption + sharing simultaneously — banned
+export class ModeError extends Error {
+    code;
+    constructor(msg, code) {
+        super(`[genkaku:${code}] ${msg}`);
+        this.code = code;
+    }
+}
+export class ModeManager {
+    onTransition;
+    state;
+    constructor(onTransition) {
+        this.onTransition = onTransition;
+        this.state = { mode: 'localPlusSharing', remoteUserActive: false, sharingActive: false };
+    }
+    current() {
+        return { ...this.state };
+    }
+    /** Enter a role. `remoteUserActive` hints whether a live remote session should
+     *  carry over (only meaningful user→user). */
+    switch(to, opts = {}) {
+        if (this.state.mode === 'user' && this.state.remoteUserActive && to !== 'user') {
+            throw new ModeError('open remote sessions must end before leaving user mode', 'remote-must-drain');
+        }
+        if (this.state.sharingActive && to === 'user') {
+            throw new ModeError('stop worker listening before becoming a remote user', 'sharing-must-drain');
+        }
+        const sharing = to !== 'user';
+        const remote = to === 'user' ? Boolean(opts.remoteUserActive) : false;
+        const before = this.state.mode;
+        this.state = { mode: to, remoteUserActive: remote, sharingActive: sharing };
+        this.onTransition?.(before, to);
+        return { ...this.state };
+    }
+    /** Sidecar calls at transport start (user mode only; D-block is enforced here). */
+    beginRemoteSession() {
+        if (this.state.mode !== 'user') {
+            throw new ModeError('remote consumption is only allowed in dedicated user mode (D-block)', 'd-block');
+        }
+        if (this.state.sharingActive) {
+            throw new ModeError('cannot consume a remote worker while sharing (D-block)', 'd-block');
+        }
+        this.state.remoteUserActive = true;
+    }
+    endRemoteSession() {
+        this.state.remoteUserActive = false;
+    }
+    /** Sidecar guard before installing /genkaku/* protocol handlers. */
+    installWorkerListeners() {
+        if (this.state.mode === 'user') {
+            throw new ModeError('worker listeners forbidden in user mode (D-block)', 'd-block');
+        }
+        if (this.state.remoteUserActive) {
+            throw new ModeError('still draining a remote session before installing listeners', 'remote-must-drain');
+        }
+        if (this.state.sharingActive) {
+            return 'already';
+        }
+        this.state.sharingActive = true;
+        this.onTransition?.('user', this.state.mode);
+        return 'installed';
+    }
+    removeWorkerListeners() {
+        if (this.state.remoteUserActive) {
+            throw new ModeError('still draining a remote session before removing listeners', 'remote-must-drain');
+        }
+        this.state.sharingActive = false;
+    }
+}
+//# sourceMappingURL=modeManager.js.map

package/dist/netconfig.d.ts

@@ -0,0 +1,11 @@
+export type NetEnvironment = 'base-sepolia' | 'base';
+export declare const CHAIN_ID: Record<NetEnvironment, 84532 | 8453>;
+export declare const CONTRACTS: Record<NetEnvironment, {
+    escrow: string;
+    registry: string;
+    usdc: string;
+}>;
+export declare const TREASURY = "0x639a2B713041e15B0c5C18710536b661d5265b48";
+export declare const HARDCODED_SEEDS: string[];
+export declare const DEFAULT_RECEIPT_STEP_TOKENS = 10;
+//# sourceMappingURL=netconfig.d.ts.map

package/dist/netconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"netconfig.d.ts","sourceRoot":"","sources":["../src/netconfig.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,MAAM,CAAA;AAEpD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,cAAc,EAAE,KAAK,GAAG,IAAI,CAGzD,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,cAAc,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAWhG,CAAA;AAED,eAAO,MAAM,QAAQ,+CAA+C,CAAA;AAWpE,eAAO,MAAM,eAAe,EAAE,MAAM,EAQhC,CAAA;AAGJ,eAAO,MAAM,2BAA2B,KAAK,CAAA"}

package/dist/netconfig.js

@@ -0,0 +1,39 @@
+// GENKAKU: network constants for the desktop client (P4).
+// Chain/data-model follows protocol/GENKAKU-P1.md + GENKAKU-P2.md.
+// Testnet values are verified on-chain (deployed 2026-11-06, contracts/README.md).
+export const CHAIN_ID = {
+    'base-sepolia': 84532,
+    base: 8453,
+};
+export const CONTRACTS = {
+    'base-sepolia': {
+        escrow: '0x8175df796A659681009BeDa4609a3cFe9d281D82',
+        registry: '0xFbE9FF497dC24bD69d13E4201418938Df7435Ff6', // v0.2 — on-chain directory (P4.9a)
+        usdc: '0xEb33DFC0424810039337a38510ef522e9E7F9727', // MockUSDC — test only
+    },
+    base: {
+        escrow: '', // deploy at mainnet launch
+        registry: '',
+        usdc: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // canonical USDC — verify vs Circle
+    },
+};
+export const TREASURY = '0x639a2B713041e15B0c5C18710536b661d5265b48';
+// Discovery (P4.9): the worker directory lives on Base — see directory.ts and
+// rpc.ts. There is NO baked bootstrap seed: genkaku.app is a static download
+// page, and neither a user nor a worker may depend on infrastructure we run.
+//
+// `GENKAKU_BOOTSTRAP_SEEDS` (comma-separated multiaddrs) is a DEVELOPMENT
+// escape hatch for a LAN bring-up or a private deployment; it is empty in
+// shipped builds and is never required for discovery to work.
+const BAKED_SEEDS = [];
+export const HARDCODED_SEEDS = (() => {
+    const fromEnv = (process.env.GENKAKU_BOOTSTRAP_SEEDS ?? '')
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s !== '');
+    return (fromEnv.length > 0 ? fromEnv : BAKED_SEEDS)
+        .filter(s => !s.includes('PLACEHOLDER'));
+})();
+// Metered receipts: default k = 10 tokens per signed ledger increment (P2 §3).
+export const DEFAULT_RECEIPT_STEP_TOKENS = 10;
+//# sourceMappingURL=netconfig.js.map

package/dist/offer.d.ts

@@ -0,0 +1,70 @@
+export type Offer = {
+    proto: 'offers/0';
+    workerName: string;
+    model: string;
+    /** 6-decimal USDC per hour of usage, as bigint */
+    pricePerHour: bigint;
+    /** coarse, self-reported (privacy: never street-level) */
+    city?: string;
+    /** 0–100; v0 local heuristic, chain-verified in P4.4 */
+    creditScore: number;
+    /** completed sessions; join into creditScore on-chain later */
+    sessionsServed: number;
+    /** where creditScore came from: chain-derived (P4.9h) or the worker's own
+     *  claim. The UI should only show a chain score as a score. */
+    creditSource?: 'chain' | 'self';
+    /** measured RTT to this worker at discovery time (ms) */
+    latencyMs?: number;
+    /** parallel sessions the worker accepts */
+    maxConcurrent?: number;
+    /** true when `workerWallet` was proven by the P4.9e hello handshake rather
+     *  than self-reported. Priced sessions should require this. */
+    walletVerified?: boolean;
+    /**
+     * The worker's EVM wallet (escrow settle recipient). The client REPLACES the
+     * self-reported value with the wallet proven by the P4.9e hello handshake and
+     * sets `walletVerified`; an offer whose claim contradicts its proof is
+     * dropped before it is ever listed.
+     */
+    workerWallet?: string;
+};
+/** JSON-safe shape used over /genkaku/offers/0 frames. */
+export type OfferWire = Omit<Offer, 'pricePerHour'> & {
+    pricePerHour: string;
+};
+export declare function toWire(offer: Offer): OfferWire;
+export declare function fromWire(wire: OfferWire): Offer;
+export declare function ceilDiv(a: bigint, b: bigint): bigint;
+/**
+ * Cumulative billed amount for a session. `unitMs` must divide 3600000
+ * (v0 default 60000 → 60 units/hour). Rate per unit is rounded UP once per
+ * hour — never per tick — so the user-perceived hourly price never exceeds
+ * the quoted pricePerHour, and the worker's per-tick exposure stays bounded.
+ */
+export declare function cumulativeBilled(pricePerHour: bigint, unitMs: number, elapsedMs: number): bigint;
+export type OfferSortKey = 'creditScore' | 'pricePerHour' | 'workerName' | 'model' | 'city' | 'latencyMs';
+/** One offer row with the address it arrived from. */
+export type AddressedOffer = {
+    addr: string;
+    offer: Offer;
+};
+/**
+ * Collapse the same worker offer reached through several multiaddrs. A stable
+ * peer can be announced over IPv4, IPv6 and relay addresses; the board should
+ * list the offer once, not once per address.
+ * @param rows - flattened offer rows in discovery order.
+ * @returns rows with duplicate (wallet-or-address, model, price) entries removed.
+ */
+export declare function dedupeOffers(rows: readonly AddressedOffer[]): AddressedOffer[];
+/** One-key sort with stable tiebreakers (name asc, then model asc). */
+export declare function sortOffers(offers: Offer[], key?: OfferSortKey, dir?: 'asc' | 'desc'): Offer[];
+export type OfferFilter = {
+    model?: string;
+    maxPricePerHour?: bigint;
+    minCredit?: number;
+    city?: string;
+    /** case-insensitive substring across workerName/model/city */
+    query?: string;
+};
+export declare function filterOffers(offers: Offer[], f: OfferFilter): Offer[];
+//# sourceMappingURL=offer.d.ts.map

package/dist/offer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offer.d.ts","sourceRoot":"","sources":["../src/offer.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,KAAK,GAAG;IAClB,KAAK,EAAE,UAAU,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAA;IACpB,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAA;IACnB,+DAA+D;IAC/D,cAAc,EAAE,MAAM,CAAA;IACtB;mEAC+D;IAC/D,YAAY,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC/B,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,2CAA2C;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;mEAC+D;IAC/D,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,0DAA0D;AAC1D,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,GAAG;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,CAAA;AAE9E,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,CAE9C;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,KAAK,CAE/C;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIpD;AAID;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAahG;AAED,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,cAAc,GAAG,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,WAAW,CAAA;AAWzG,sDAAsD;AACtD,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAA;AAE3D;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,cAAc,EAAE,GAAG,cAAc,EAAE,CAW9E;AAED,uEAAuE;AACvE,wBAAgB,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,GAAE,YAA4B,EAAE,GAAG,GAAE,KAAK,GAAG,MAAe,GAAG,KAAK,EAAE,CAOpH;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,EAAE,WAAW,GAAG,KAAK,EAAE,CASrE"}

package/dist/offer.js

@@ -0,0 +1,84 @@
+// GENKAKU: worker offer board (P4.3 marketplace).
+// A worker publishes one Offer row per (model, price) it chooses to serve.
+// Price is FREELY set by the worker and quoted PER HOUR of user usage time
+// (MockUSDC 6 decimals in testnet; canonical USDC 6 decimals in prod). Billing
+// accrues per STARTED MINUTE: worker's max unbilled exposure = one minute.
+// Credit score: v0 is a local heuristic (sessions served); P4.4 upgrades it to
+// the on-chain settled-claim ratio from JobEscrow/WorkerRegistry events.
+export function toWire(offer) {
+    return { ...offer, pricePerHour: offer.pricePerHour.toString() };
+}
+export function fromWire(wire) {
+    return { ...wire, pricePerHour: BigInt(wire.pricePerHour), proto: 'offers/0' };
+}
+export function ceilDiv(a, b) {
+    if (b <= 0n) {
+        throw new Error('[genkaku:pricing] divisor must be positive');
+    }
+    return (a + b - 1n) / b;
+}
+const MS_PER_HOUR = 3600000n;
+/**
+ * Cumulative billed amount for a session. `unitMs` must divide 3600000
+ * (v0 default 60000 → 60 units/hour). Rate per unit is rounded UP once per
+ * hour — never per tick — so the user-perceived hourly price never exceeds
+ * the quoted pricePerHour, and the worker's per-tick exposure stays bounded.
+ */
+export function cumulativeBilled(pricePerHour, unitMs, elapsedMs) {
+    if (unitMs <= 0) {
+        throw new Error('[genkaku:pricing] unitMs must be positive');
+    }
+    const unit = BigInt(unitMs);
+    if (MS_PER_HOUR % unit !== 0n) {
+        throw new Error('[genkaku:pricing] unitMs must divide 3600000');
+    }
+    const units = Math.ceil(elapsedMs / unitMs);
+    if (units <= 0) {
+        return 0n;
+    }
+    return BigInt(units) * ceilDiv(pricePerHour, MS_PER_HOUR / unit);
+}
+const comparators = {
+    creditScore: (a, b) => a.creditScore - b.creditScore,
+    pricePerHour: (a, b) => (a.pricePerHour <= b.pricePerHour ? -1 : 1),
+    workerName: (a, b) => a.workerName.localeCompare(b.workerName),
+    model: (a, b) => a.model.localeCompare(b.model),
+    city: (a, b) => (a.city ?? '').localeCompare(b.city ?? ''),
+    latencyMs: (a, b) => (a.latencyMs ?? Number.POSITIVE_INFINITY) - (b.latencyMs ?? Number.POSITIVE_INFINITY),
+};
+/**
+ * Collapse the same worker offer reached through several multiaddrs. A stable
+ * peer can be announced over IPv4, IPv6 and relay addresses; the board should
+ * list the offer once, not once per address.
+ * @param rows - flattened offer rows in discovery order.
+ * @returns rows with duplicate (wallet-or-address, model, price) entries removed.
+ */
+export function dedupeOffers(rows) {
+    const seen = new Set();
+    const out = [];
+    for (const row of rows) {
+        const worker = row.offer.workerWallet ?? row.addr;
+        const key = `${worker}|${row.offer.model}|${row.offer.pricePerHour.toString()}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(row);
+    }
+    return out;
+}
+/** One-key sort with stable tiebreakers (name asc, then model asc). */
+export function sortOffers(offers, key = 'creditScore', dir = 'desc') {
+    const mul = dir === 'desc' ? -1 : 1;
+    return [...offers].sort((a, b) => mul * comparators[key](a, b)
+        || comparators.workerName(a, b)
+        || comparators.model(a, b));
+}
+export function filterOffers(offers, f) {
+    const q = f.query?.toLowerCase();
+    return offers.filter(o => (!f.model || o.model === f.model)
+        && (!f.minCredit || o.creditScore >= f.minCredit)
+        && (!f.city || o.city === f.city)
+        && (!q || `${o.workerName} ${o.model} ${o.city ?? ''}`.toLowerCase().includes(q))
+        && (!f.maxPricePerHour || o.pricePerHour <= f.maxPricePerHour));
+}
+//# sourceMappingURL=offer.js.map

package/dist/ollama.d.ts

@@ -0,0 +1,53 @@
+import { type ModelInfo, type PullProgress } from './llmBridge.ts';
+/** Facts the settings page renders before it offers a next step. */
+export type OllamaState = {
+    /** an `ollama` executable was found on this machine */
+    installed: boolean;
+    /** the local HTTP API answers right now */
+    running: boolean;
+    /** version reported by `GET /api/version`, when running */
+    version?: string;
+    /** base URL the plugin uses */
+    host: string;
+    /** official installer page for this platform */
+    downloadUrl: string;
+    /** installed models, empty when the service is not running */
+    models: ModelInfo[];
+    /** last detection or start failure, for the onboarding hint */
+    error?: string;
+};
+/** Official installer page per platform. */
+export declare function ollamaDownloadUrl(platform?: NodeJS.Platform): string;
+/**
+ * Locate an `ollama` executable without trusting the GUI process PATH.
+ *
+ * A packaged macOS app inherits a minimal PATH, so the Homebrew and app-bundle
+ * locations are probed directly; on Windows the per-user installer path is the
+ * usual one.
+ * @param platform - target platform, injectable for tests.
+ * @param environment - environment to read PATH from.
+ * @returns absolute executable path, or undefined when Ollama is absent.
+ */
+export declare function locateOllama(platform?: NodeJS.Platform, environment?: NodeJS.ProcessEnv): string | undefined;
+export type OllamaSupervisor = {
+    /** Detect the binary, probe the service and list models. */
+    state: () => Promise<OllamaState>;
+    /** Start `ollama serve` when installed but stopped; idempotent. */
+    ensureRunning: () => Promise<OllamaState>;
+    /** Download a registry model, forwarding progress frames. */
+    pull: (model: string, onProgress?: (p: PullProgress) => void, signal?: AbortSignal) => Promise<{
+        status: string;
+    }>;
+    /** Remove a locally installed model. */
+    remove: (model: string) => Promise<void>;
+    /** Stop the child this supervisor started, if any. */
+    dispose: () => void;
+};
+/**
+ * Build the worker-side Ollama supervisor.
+ * @param host - local Ollama base URL.
+ * @param log - diagnostic line sink.
+ * @returns supervisor over the local install.
+ */
+export declare function createOllamaSupervisor(host: string, log: (line: string) => void): OllamaSupervisor;
+//# sourceMappingURL=ollama.d.ts.map

package/dist/ollama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../src/ollama.ts"],"names":[],"mappings":"AAWA,OAAO,EAAe,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE/E,oEAAoE;AACpE,MAAM,MAAM,WAAW,GAAG;IACxB,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAA;IAClB,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAA;IAChB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAA;IACnB,8DAA8D;IAC9D,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,4CAA4C;AAC5C,wBAAgB,iBAAiB,CAAC,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAAG,MAAM,CAItF;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,GAAE,MAAM,CAAC,QAA2B,EAC5C,WAAW,GAAE,MAAM,CAAC,UAAwB,GAC3C,MAAM,GAAG,SAAS,CAuBpB;AASD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4DAA4D;IAC5D,KAAK,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IACjC,mEAAmE;IACnE,aAAa,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;IACzC,6DAA6D;IAC7D,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAClH,wCAAwC;IACxC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACxC,sDAAsD;IACtD,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,gBAAgB,CA0FlG"}

package/dist/ollama.js

@@ -0,0 +1,162 @@
+// GENKAKU: local Ollama lifecycle for worker onboarding (P4.7b).
+//
+// The desktop ships no multi-GB runtime. A worker either already runs Ollama
+// or is guided to install it; this module only detects, starts and talks to
+// the local HTTP API. Model management lives in llmBridge.ollamaAdmin.
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { ollamaAdmin } from "./llmBridge.js";
+/** Official installer page per platform. */
+export function ollamaDownloadUrl(platform = process.platform) {
+    if (platform === 'darwin')
+        return 'https://ollama.com/download/mac';
+    if (platform === 'win32')
+        return 'https://ollama.com/download/windows';
+    return 'https://ollama.com/download/linux';
+}
+/**
+ * Locate an `ollama` executable without trusting the GUI process PATH.
+ *
+ * A packaged macOS app inherits a minimal PATH, so the Homebrew and app-bundle
+ * locations are probed directly; on Windows the per-user installer path is the
+ * usual one.
+ * @param platform - target platform, injectable for tests.
+ * @param environment - environment to read PATH from.
+ * @returns absolute executable path, or undefined when Ollama is absent.
+ */
+export function locateOllama(platform = process.platform, environment = process.env) {
+    const executable = platform === 'win32' ? 'ollama.exe' : 'ollama';
+    // Scan PATH directly: a packaged GUI app cannot rely on `which`/`where`
+    // because the inherited PATH is minimal and those tools may be unresolvable.
+    for (const dir of (environment.PATH ?? '').split(delimiter)) {
+        if (dir === '')
+            continue;
+        const candidate = join(dir, executable);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    const candidates = platform === 'darwin'
+        ? [
+            '/usr/local/bin/ollama',
+            '/opt/homebrew/bin/ollama',
+            '/Applications/Ollama.app/Contents/Resources/ollama',
+            join(homedir(), 'Applications/Ollama.app/Contents/Resources/ollama'),
+        ]
+        : platform === 'win32'
+            ? [
+                join(environment.LOCALAPPDATA ?? join(homedir(), 'AppData/Local'), 'Programs/Ollama/ollama.exe'),
+                join(environment.ProgramFiles ?? 'C:/Program Files', 'Ollama/ollama.exe'),
+            ]
+            : ['/usr/local/bin/ollama', '/usr/bin/ollama', '/snap/bin/ollama'];
+    return candidates.find(candidate => existsSync(candidate));
+}
+/** Read one JSON document from the local API with a bounded wait. */
+async function getJson(url, timeoutMs = 1500) {
+    const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!response.ok)
+        throw new Error(`${url} refused (${response.status})`);
+    return await response.json();
+}
+/**
+ * Build the worker-side Ollama supervisor.
+ * @param host - local Ollama base URL.
+ * @param log - diagnostic line sink.
+ * @returns supervisor over the local install.
+ */
+export function createOllamaSupervisor(host, log) {
+    const admin = ollamaAdmin(host);
+    const base = host.replace(/\/$/u, '');
+    let child;
+    let starting;
+    const running = async () => {
+        try {
+            const versionDoc = await getJson(`${base}/api/version`);
+            const models = await admin.list();
+            return {
+                running: true,
+                ...(typeof versionDoc.version === 'string' ? { version: versionDoc.version } : {}),
+                models,
+            };
+        }
+        catch (error) {
+            return { running: false, models: [], error: error instanceof Error ? error.message : String(error) };
+        }
+    };
+    const state = async () => {
+        const probe = await running();
+        const binary = locateOllama();
+        if (probe.running) {
+            return {
+                installed: true,
+                running: true,
+                ...(probe.version === undefined ? {} : { version: probe.version }),
+                host, downloadUrl: ollamaDownloadUrl(), models: probe.models,
+            };
+        }
+        return {
+            installed: binary !== undefined,
+            running: false,
+            host,
+            downloadUrl: ollamaDownloadUrl(),
+            models: [],
+            ...(binary === undefined
+                ? { error: 'ollama executable not found' }
+                : probe.error === undefined ? {} : { error: probe.error }),
+        };
+    };
+    const start = async () => {
+        const binary = locateOllama();
+        if (binary === undefined)
+            return await state();
+        const url = new URL(base);
+        log(`ollama: starting ${binary} serve (OLLAMA_HOST=${url.host})`);
+        const spawned = spawn(binary, ['serve'], {
+            env: { ...process.env, OLLAMA_HOST: url.host },
+            stdio: 'ignore',
+            detached: false,
+        });
+        child = spawned;
+        spawned.once('error', (error) => { log(`ollama spawn failed (${error.message})`); });
+        spawned.once('exit', (code, signal) => {
+            if (child === spawned)
+                child = undefined;
+            log(`ollama exited (${code ?? signal ?? 'unknown'})`);
+        });
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            const probe = await running();
+            if (probe.running)
+                return await state();
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+        const current = await state();
+        return { ...current, error: current.error ?? 'ollama did not answer after 10s' };
+    };
+    return {
+        state,
+        ensureRunning: async () => {
+            const current = await state();
+            if (current.running || !current.installed)
+                return current;
+            starting ??= start().finally(() => { starting = undefined; });
+            return await starting;
+        },
+        pull: async (model, onProgress, signal) => await admin.pull(model, onProgress, signal),
+        remove: async (model) => {
+            const response = await fetch(`${base}/api/delete`, {
+                method: 'DELETE',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ model }),
+            });
+            if (!response.ok)
+                throw new Error(`ollama delete refused (${response.status})`);
+        },
+        dispose: () => {
+            if (child !== undefined && !child.killed)
+                child.kill();
+            child = undefined;
+        },
+    };
+}
+//# sourceMappingURL=ollama.js.map