@genkaku/dsh-runtime 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GenKaKu Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * DeepSeek Harness adapter for the GenKaKu protocol.
+ *
+ * One runtime, two plugin identities: `@genkaku/dsh-worker-plugin` pins a
+ * serving role and `@genkaku/dsh-user-plugin` pins the consuming role. Keeping
+ * the implementation here means the two packages cannot drift apart.
+ */
+export { Config, DEFAULT_SETTINGS_NS, GenkakuRuntime, defineGenkakuPlugin } from './runtime.ts';
+export type { Config as GenkakuConfig } from './runtime.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAC/F,YAAY,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,9 @@
+/**
+ * DeepSeek Harness adapter for the GenKaKu protocol.
+ *
+ * One runtime, two plugin identities: `@genkaku/dsh-worker-plugin` pins a
+ * serving role and `@genkaku/dsh-user-plugin` pins the consuming role. Keeping
+ * the implementation here means the two packages cannot drift apart.
+ */
+export { Config, DEFAULT_SETTINGS_NS, GenkakuRuntime, defineGenkakuPlugin } from "./runtime.js";
+//# sourceMappingURL=index.js.map

package/dist/runtime.d.ts

@@ -0,0 +1,272 @@
+import type { Context, Logger, Volatile } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type KeyVault } from '@genkaku/protocol';
+import { ModeManager, type RoleMode } from '@genkaku/protocol';
+import { type NetEnvironment } from '@genkaku/protocol';
+/** Settings document this runtime reads; each adapter passes its own id so the
+ *  worker and user plugins can be installed side by side. */
+export declare const DEFAULT_SETTINGS_NS = "genkaku";
+/** One (model, price) row the worker publishes on the offer board. */
+export type CatalogEntry = {
+    /** Ollama model name, e.g. "llama3:8b" */
+    model: string;
+    /** 6-decimal USDC per hour, as a decimal string */
+    pricePerHour: string;
+    /** coarse, self-reported city (privacy: never street-level) */
+    city?: string;
+    /** 0–100 self-reported credit heuristic */
+    creditScore?: number;
+    /** completed sessions (joins into creditScore on-chain later) */
+    sessionsServed?: number;
+    /** parallel sessions the worker accepts */
+    maxConcurrent?: number;
+};
+export interface Config {
+    /** user = consume remote workers; localPlusSharing / workerDedicated = serve */
+    mode: Volatile<RoleMode>;
+    /** data-plane chain the receipts bind to */
+    env: NetEnvironment;
+    /** local OpenAI bridge port (0 = ephemeral; user mode only) */
+    port: Volatile<number>;
+    /** worker multiaddrs; empty = discover through the baked seed peers */
+    workers: Volatile<string[]>;
+    /** open/settle real escrows (Base Sepolia only). Default ON: a worker's
+     *  paywall is ON by default, so a free-session client would always be
+     *  refused. Set false only for an offline/dev pair. */
+    settle: boolean;
+    /** refuse to serve unless the client's escrow pays this worker (P4.9d).
+     *  Defaults ON: a directory entry with the gate off is free GPU for anyone
+     *  who scans the chain. Dev machines opt out explicitly. */
+    paywall: boolean;
+    /** directory for the encrypted key vault (default ~/.dsh/genkaku) */
+    keyDir: string;
+    /** worker-side offer rows */
+    catalog: CatalogEntry[];
+    /** worker-side libp2p listen addresses */
+    listen: string[];
+    /** publish this worker's public address to the on-chain directory. OFF by
+     *  default: a global IP is permanent once written (privacy decision §25). */
+    publishAddress: boolean;
+    /** worker name shown on the offer board */
+    workerName: string;
+    /** start the local `ollama serve` before the worker sidecar starts */
+    spawnOllama: boolean;
+    /** local Ollama base URL */
+    ollamaHost: string;
+}
+/** Validated plugin configuration. */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    mode: z<"user" | "localPlusSharing" | "workerDedicated", "user" | "localPlusSharing" | "workerDedicated", "volatile-defined">;
+    env: z<"base-sepolia" | "base", "base-sepolia" | "base", "defined">;
+    port: z<number, number, "volatile-defined">;
+    workers: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    settle: z<boolean, boolean, "defined">;
+    paywall: z<boolean, boolean, "defined">;
+    keyDir: z<string, string, "defined">;
+    catalog: z<({
+        model?: string | null | undefined;
+        pricePerHour?: string | null | undefined;
+        city?: string | null | undefined;
+        creditScore?: number | null | undefined;
+        sessionsServed?: number | null | undefined;
+        maxConcurrent?: number | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+        model: z<string, string, "defined">;
+        pricePerHour: z<string, string, "defined">;
+        city: z<string, string, "plain">;
+        creditScore: z<number, number, "defined">;
+        sessionsServed: z<number, number, "defined">;
+        maxConcurrent: z<number, number, "plain">;
+    }>>[], "defined">;
+    listen: z<string[], string[], "defined">;
+    publishAddress: z<boolean, boolean, "defined">;
+    workerName: z<string, string, "defined">;
+    spawnOllama: z<boolean, boolean, "defined">;
+    ollamaHost: z<string, string, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    mode: z<"user" | "localPlusSharing" | "workerDedicated", "user" | "localPlusSharing" | "workerDedicated", "volatile-defined">;
+    env: z<"base-sepolia" | "base", "base-sepolia" | "base", "defined">;
+    port: z<number, number, "volatile-defined">;
+    workers: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    settle: z<boolean, boolean, "defined">;
+    paywall: z<boolean, boolean, "defined">;
+    keyDir: z<string, string, "defined">;
+    catalog: z<({
+        model?: string | null | undefined;
+        pricePerHour?: string | null | undefined;
+        city?: string | null | undefined;
+        creditScore?: number | null | undefined;
+        sessionsServed?: number | null | undefined;
+        maxConcurrent?: number | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+        model: z<string, string, "defined">;
+        pricePerHour: z<string, string, "defined">;
+        city: z<string, string, "plain">;
+        creditScore: z<number, number, "defined">;
+        sessionsServed: z<number, number, "defined">;
+        maxConcurrent: z<number, number, "plain">;
+    }>>[], "defined">;
+    listen: z<string[], string[], "defined">;
+    publishAddress: z<boolean, boolean, "defined">;
+    workerName: z<string, string, "defined">;
+    spawnOllama: z<boolean, boolean, "defined">;
+    ollamaHost: z<string, string, "defined">;
+}>>, "plain">;
+/**
+ * Start the side that this machine's role allows. The controller reads the
+ * volatile mode once at startup; startup is awaited directly so a failure
+ * rejects the plugin, and only a successful start registers teardown.
+ */
+/**
+ * Build one DeepSeek Harness plugin from this runtime.
+ *
+ * The worker and user adapters are separate packages, but they share one
+ * implementation: what differs is the plugin id, the settings namespace, and
+ * the role it is allowed to run. Returns the exact shape dsh expects from a
+ * plugin module (`name`, `inject`, `Config`, `apply`).
+ *
+ * @param options.pluginName - cordis plugin name, e.g. `genkaku-worker`.
+ * @param options.settingsNs - settings document id this adapter owns.
+ * @param options.role - serving or consuming; overrides any stored mode.
+ */
+export declare function defineGenkakuPlugin(options: {
+    pluginName: string;
+    settingsNs: string;
+    role?: RoleMode;
+    /** Extra cordis services the adapter half needs (e.g. `llm`). */
+    injectExtra?: readonly string[];
+    /** Runs once the runtime is up; where an adapter registers its own services. */
+    onStarted?: (ctx: Context, config: Config) => void;
+}): {
+    name: string;
+    inject: readonly string[];
+    Config: z<Schemastery.ObjectS<NoInfer<{
+        mode: z<"user" | "localPlusSharing" | "workerDedicated", "user" | "localPlusSharing" | "workerDedicated", "volatile-defined">;
+        env: z<"base-sepolia" | "base", "base-sepolia" | "base", "defined">;
+        port: z<number, number, "volatile-defined">;
+        workers: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+        settle: z<boolean, boolean, "defined">;
+        paywall: z<boolean, boolean, "defined">;
+        keyDir: z<string, string, "defined">;
+        catalog: z<({
+            model?: string | null | undefined;
+            pricePerHour?: string | null | undefined;
+            city?: string | null | undefined;
+            creditScore?: number | null | undefined;
+            sessionsServed?: number | null | undefined;
+            maxConcurrent?: number | null | undefined;
+        } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+            model: z<string, string, "defined">;
+            pricePerHour: z<string, string, "defined">;
+            city: z<string, string, "plain">;
+            creditScore: z<number, number, "defined">;
+            sessionsServed: z<number, number, "defined">;
+            maxConcurrent: z<number, number, "plain">;
+        }>>[], "defined">;
+        listen: z<string[], string[], "defined">;
+        publishAddress: z<boolean, boolean, "defined">;
+        workerName: z<string, string, "defined">;
+        spawnOllama: z<boolean, boolean, "defined">;
+        ollamaHost: z<string, string, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        mode: z<"user" | "localPlusSharing" | "workerDedicated", "user" | "localPlusSharing" | "workerDedicated", "volatile-defined">;
+        env: z<"base-sepolia" | "base", "base-sepolia" | "base", "defined">;
+        port: z<number, number, "volatile-defined">;
+        workers: z<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+        settle: z<boolean, boolean, "defined">;
+        paywall: z<boolean, boolean, "defined">;
+        keyDir: z<string, string, "defined">;
+        catalog: z<({
+            model?: string | null | undefined;
+            pricePerHour?: string | null | undefined;
+            city?: string | null | undefined;
+            creditScore?: number | null | undefined;
+            sessionsServed?: number | null | undefined;
+            maxConcurrent?: number | null | undefined;
+        } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+            model: z<string, string, "defined">;
+            pricePerHour: z<string, string, "defined">;
+            city: z<string, string, "plain">;
+            creditScore: z<number, number, "defined">;
+            sessionsServed: z<number, number, "defined">;
+            maxConcurrent: z<number, number, "plain">;
+        }>>[], "defined">;
+        listen: z<string[], string[], "defined">;
+        publishAddress: z<boolean, boolean, "defined">;
+        workerName: z<string, string, "defined">;
+        spawnOllama: z<boolean, boolean, "defined">;
+        ollamaHost: z<string, string, "defined">;
+    }>>, "plain">;
+    apply: (ctx: Context, config: Config) => Promise<void>;
+};
+/** Owns the running halves so the mode starter and teardown share one state. */
+export declare class GenkakuRuntime {
+    private readonly ctx;
+    private readonly config;
+    private readonly vault;
+    private readonly modeManager;
+    private readonly log;
+    private readonly keyDir;
+    /**
+     * Mode this adapter is allowed to run. The worker plugin pins a serving
+     * mode and the user plugin pins `user`, so installing both cannot make
+     * them fight over the same peer identity and listen ports.
+     */
+    private readonly forcedMode?;
+    /** Settings document id; defaults to the single-plugin namespace. */
+    private readonly settingsNs;
+    private node;
+    private ollama;
+    private stop;
+    private statusServer;
+    private applied;
+    /** Worker-side address watcher: advertise only when the announced set moves. */
+    private advertiseState;
+    private advertiseTimer;
+    private reconfigureQueue;
+    private modeTicker;
+    private pendingMode;
+    private modeUpdating;
+    constructor(ctx: Context, config: Config, vault: KeyVault, modeManager: ModeManager, log: Logger, keyDir: string, 
+    /**
+     * Mode this adapter is allowed to run. The worker plugin pins a serving
+     * mode and the user plugin pins `user`, so installing both cannot make
+     * them fight over the same peer identity and listen ports.
+     */
+    forcedMode?: RoleMode | undefined, 
+    /** Settings document id; defaults to the single-plugin namespace. */
+    settingsNs?: string);
+    /** Read the configured mode once, switch the guard, and start its half. */
+    applyMode(): Promise<void>;
+    /** Store the latest requested mode; the runtime ticker applies it. */
+    private scheduleMode;
+    /** Persistent 300 ms pump, created outside request contexts. */
+    private startModeTicker;
+    private stopModeTicker;
+    /** Apply the latest pending mode, retrying only mid-reload failures. */
+    private flushMode;
+    /** Serialize settings-driven restarts; each call waits for the previous one. */
+    reconfigure(): Promise<void>;
+    /** Restart only when a startup field changed; otherwise keep serving. */
+    private reconfigureNow;
+    private startupState;
+    /** User half: a bare libp2p dial node plus the OpenAI-compatible bridge. */
+    startUser(): Promise<void>;
+    /** Worker half: the libp2p sidecar, its status dashboard, and Ollama. */
+    startWorker(): Promise<void>;
+    /** Poll the announce set; advertise only after it has been stable for two
+     *  checks. A worker's listen addrs flap while interfaces come up (Wi-Fi,
+     *  VPN, sleep/wake) and every advertise is a chain write — this turns a
+     *  flap into zero transactions instead of a burst of them. */
+    private startAdvertiseWatch;
+    private stopAdvertiseWatch;
+    private checkAdvertise;
+    /** Stop the running halves without touching the lifetime mode ticker. */
+    private stopServices;
+    /** Shut down: stop services and the one lifetime mode ticker. */
+    stopAll(): Promise<void>;
+    /** Plugin-lifecycle shutdown alias. */
+    dispose(): Promise<void>;
+}
+/** Best-effort local Ollama service; a failed spawn leaves an existing daemon alone. */
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/runtime.js

@@ -0,0 +1,726 @@
+// GENKAKU for dsh — Cordis plugin entry.
+// User mode starts the OpenAI-compatible local bridge (dsh dials it as a plain
+// model provider); worker modes start the libp2p sidecar that serves the local
+// Ollama instance. The mode manager enforces the D-block (never consume and
+// serve on one machine at the same time).
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import z from '@deepseek-ai/schemastery';
+import { startOpenAiBridge } from '@genkaku/protocol';
+import { advertiseWorker, deactivateWorker, hasPublicAddr, locatorOf, publicClientFor, readWorker, readWalletBalances, readWorkerLocators, registerWorkerWithLocator, walletAddress, walletClientFor, } from '@genkaku/protocol';
+import { fetchSeedPeers } from '@genkaku/protocol';
+import { loadDirectory, syncDirectory, workerAddrs } from '@genkaku/protocol';
+import { createKeyVault } from '@genkaku/protocol';
+import { createOllamaChatSource, createOllamaSource } from '@genkaku/protocol';
+import { createOllamaSupervisor } from '@genkaku/protocol';
+import { ModeManager } from '@genkaku/protocol';
+import { probeRpc } from '@genkaku/protocol';
+import { HARDCODED_SEEDS } from '@genkaku/protocol';
+import { toWire } from '@genkaku/protocol';
+import { CreditTracker } from '@genkaku/protocol';
+import { createPaywall } from '@genkaku/protocol';
+import { readPublishOptIn, writePublishOptIn } from '@genkaku/protocol';
+import { createSidecar, createUserNode } from '@genkaku/protocol';
+import { POLICY_VERSION, peerIdDigestOf, policyHashOf } from '@genkaku/protocol';
+import { startStatusServer } from '@genkaku/protocol';
+/** Settings document this runtime reads; each adapter passes its own id so the
+ *  worker and user plugins can be installed side by side. */
+export const DEFAULT_SETTINGS_NS = 'genkaku';
+const catalogEntry = z.object({
+    model: z.string().min(1).required(),
+    pricePerHour: z.string().pattern(/^\d+$/).default('0'),
+    city: z.string(),
+    creditScore: z.natural().max(100).default(50),
+    sessionsServed: z.natural().default(0),
+    maxConcurrent: z.natural().min(1),
+});
+/** Validated plugin configuration. */
+export const Config = z.object({
+    mode: z.union(['user', 'localPlusSharing', 'workerDedicated']).default('user').volatile(),
+    env: z.union(['base-sepolia', 'base']).default('base-sepolia'),
+    port: z.natural().max(65535).default(47821).volatile(),
+    workers: z.array(z.string().min(1)).default([]).volatile(),
+    settle: z.boolean().default(true),
+    paywall: z.boolean().default(true),
+    keyDir: z.string().min(1).default(join(homedir(), '.dsh', 'genkaku')),
+    catalog: z.array(catalogEntry).default([]),
+    // IPv4 and IPv6 need separate binds (a /ip6/::/ bind is v6-only), and a
+    // global IPv6 address means a directly dialable worker with no NAT at all —
+    // the cheapest way for a dorm/public-wifi peer to be reachable (P4.9j).
+    listen: z.array(z.string().min(1)).default(['/ip4/0.0.0.0/tcp/4001', '/ip6/::/tcp/4002']),
+    publishAddress: z.boolean().default(false),
+    workerName: z.string().min(1).default('dsh-genkaku'),
+    spawnOllama: z.boolean().default(true),
+    ollamaHost: z.string().pattern(/^https?:\/\//).default('http://127.0.0.1:11434'),
+});
+/**
+ * Start the side that this machine's role allows. The controller reads the
+ * volatile mode once at startup; startup is awaited directly so a failure
+ * rejects the plugin, and only a successful start registers teardown.
+ */
+/**
+ * Build one DeepSeek Harness plugin from this runtime.
+ *
+ * The worker and user adapters are separate packages, but they share one
+ * implementation: what differs is the plugin id, the settings namespace, and
+ * the role it is allowed to run. Returns the exact shape dsh expects from a
+ * plugin module (`name`, `inject`, `Config`, `apply`).
+ *
+ * @param options.pluginName - cordis plugin name, e.g. `genkaku-worker`.
+ * @param options.settingsNs - settings document id this adapter owns.
+ * @param options.role - serving or consuming; overrides any stored mode.
+ */
+export function defineGenkakuPlugin(options) {
+    const { pluginName, settingsNs, role, injectExtra = [], onStarted } = options;
+    async function apply(ctx, config) {
+        ctx.inject(['settings'], (child) => { child.effect(() => child.settings.configure({ auto: false }, ctx.fiber)); });
+        const log = ctx.logger(pluginName);
+        const keyDir = config.keyDir;
+        // rpc.ts keeps its probe cache next to the rest of the GenKaKu state; the
+        // module reads this once per call, so exporting the resolved dir is enough.
+        process.env.GENKAKU_KEY_DIR = keyDir;
+        // dsh exposes no safeStorage/keyring codec, so createKeyVault falls back to a
+        // plaintext pass-through. Say so at startup: signing keys stay unencrypted.
+        log.warn('%s key vault at %s is PLAINTEXT (no key codec available on this host); '
+            + 'user/worker signing keys are stored unencrypted — restrict the directory permissions', pluginName, keyDir);
+        const vault = createKeyVault({ dir: keyDir });
+        const modeManager = new ModeManager();
+        const runtime = new GenkakuRuntime(ctx, config, vault, modeManager, log, keyDir, role, settingsNs);
+        try {
+            await runtime.applyMode();
+        }
+        catch (error) {
+            await runtime.dispose();
+            throw error;
+        }
+        // Live edits to the volatile startup fields restart the owning half on demand.
+        ctx.effect(() => ctx.on('settings/document-updated', (ns) => {
+            if (String(ns) === settingsNs)
+                void runtime.reconfigure();
+        }), `${pluginName}: settings updates`);
+        // Startup is complete, so the disposer body stays synchronous: it returns
+        // the async teardown for Cordis to await at unload.
+        ctx.effect(() => () => runtime.dispose(), `${pluginName}: bridge and sidecar lifecycle`);
+        onStarted?.(ctx, config);
+    }
+    return {
+        name: pluginName,
+        inject: ['settings', ...injectExtra],
+        Config,
+        apply,
+    };
+}
+/** Owns the running halves so the mode starter and teardown share one state. */
+export class GenkakuRuntime {
+    ctx;
+    config;
+    vault;
+    modeManager;
+    log;
+    keyDir;
+    forcedMode;
+    settingsNs;
+    node = null;
+    ollama = null;
+    stop = null;
+    statusServer = null;
+    applied = null;
+    /** Worker-side address watcher: advertise only when the announced set moves. */
+    advertiseState = null;
+    advertiseTimer = null;
+    reconfigureQueue = Promise.resolve();
+    modeTicker = null;
+    pendingMode = null;
+    modeUpdating = false;
+    constructor(ctx, config, vault, modeManager, log, keyDir, 
+    /**
+     * Mode this adapter is allowed to run. The worker plugin pins a serving
+     * mode and the user plugin pins `user`, so installing both cannot make
+     * them fight over the same peer identity and listen ports.
+     */
+    forcedMode, 
+    /** Settings document id; defaults to the single-plugin namespace. */
+    settingsNs = DEFAULT_SETTINGS_NS) {
+        this.ctx = ctx;
+        this.config = config;
+        this.vault = vault;
+        this.modeManager = modeManager;
+        this.log = log;
+        this.keyDir = keyDir;
+        this.forcedMode = forcedMode;
+        this.settingsNs = settingsNs;
+    }
+    /** Read the configured mode once, switch the guard, and start its half. */
+    async applyMode() {
+        this.startModeTicker();
+        const mode = this.forcedMode ?? this.config.mode.get();
+        this.modeManager.switch(mode);
+        if (mode === 'user')
+            await this.startUser();
+        else
+            await this.startWorker();
+        this.applied = this.startupState(mode);
+    }
+    /** Store the latest requested mode; the runtime ticker applies it. */
+    scheduleMode(mode) {
+        this.pendingMode = { mode, retries: 4 };
+        modeLog('queued mode=' + mode);
+    }
+    /** Persistent 300 ms pump, created outside request contexts. */
+    startModeTicker() {
+        if (this.modeTicker != null)
+            return;
+        this.modeTicker = setInterval(() => { this.flushMode(); }, 300);
+        this.modeTicker.unref();
+    }
+    stopModeTicker() {
+        if (this.modeTicker != null) {
+            clearInterval(this.modeTicker);
+            this.modeTicker = null;
+        }
+        this.pendingMode = null;
+    }
+    /** Apply the latest pending mode, retrying only mid-reload failures. */
+    flushMode() {
+        if (this.modeUpdating || this.pendingMode == null)
+            return;
+        const pending = this.pendingMode;
+        this.pendingMode = null;
+        this.modeUpdating = true;
+        void this.ctx.settings.update(this.settingsNs, { mode: pending.mode }).then(() => {
+            this.modeUpdating = false;
+            modeLog('applied mode=' + pending.mode);
+        }).catch((error) => {
+            this.modeUpdating = false;
+            const message = error instanceof Error ? error.message : String(error);
+            if (/nested|hmr/i.test(message) && pending.retries > 0 && this.pendingMode == null) {
+                this.pendingMode = { mode: pending.mode, retries: pending.retries - 1 };
+                modeLog('retry ' + (5 - pending.retries) + ' after ' + message);
+                return;
+            }
+            modeLog('mode switch error ' + message);
+            this.log.warn('mode switch failed (%s)', message);
+        });
+    }
+    /** Serialize settings-driven restarts; each call waits for the previous one. */
+    reconfigure() {
+        modeLog('request');
+        const run = this.reconfigureQueue.then(() => this.reconfigureNow());
+        this.reconfigureQueue = run.catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            modeLog('error ' + message);
+            this.log.warn('reconfigure failed (%s)', message);
+        });
+        return this.reconfigureQueue;
+    }
+    /** Restart only when a startup field changed; otherwise keep serving. */
+    async reconfigureNow() {
+        const mode = this.forcedMode ?? this.config.mode.get();
+        const next = this.startupState(mode);
+        modeLog('attempt mode=' + mode + ' class=' + next.modeClass + ' port=' + next.port);
+        const changed = [];
+        if (this.applied == null) {
+            changed.push('initial');
+        }
+        else {
+            if (this.applied.modeClass !== next.modeClass)
+                changed.push('modeClass');
+            if (this.applied.port !== next.port)
+                changed.push('port');
+            if (this.applied.workers !== next.workers)
+                changed.push('workers');
+        }
+        if (changed.length === 0) {
+            modeLog('skip unchanged class=' + next.modeClass + ' port=' + next.port);
+            return;
+        }
+        modeLog('restart changed=' + changed.join(',') + ' to=' + next.modeClass + ':' + next.port);
+        this.log.info('settings changed; restarting the %s half', next.modeClass);
+        await this.stopServices();
+        this.modeManager.switch(mode);
+        if (mode === 'user')
+            await this.startUser();
+        else
+            await this.startWorker();
+        this.applied = next;
+        modeLog('restarted class=' + next.modeClass + ' port=' + next.port);
+    }
+    startupState(mode) {
+        return {
+            modeClass: mode === 'user' ? 'user' : 'worker',
+            port: this.config.port.get(),
+            workers: [...this.config.workers.get()].join('\u0000'),
+        };
+    }
+    /** User half: a bare libp2p dial node plus the OpenAI-compatible bridge. */
+    async startUser() {
+        const userNode = await createUserNode();
+        this.node = userNode;
+        void probeRpc(this.config.env, this.log);
+        const configuredWorkers = [...this.config.workers.get()];
+        const env = this.config.env;
+        const publicC = publicClientFor(env);
+        // Chain directory first (P4.9b): a cold client with an empty config needs
+        // nothing but a public Base RPC. A read failure falls back to the cached
+        // directory, then to the seed list only if one was explicitly configured.
+        let discovered = [];
+        try {
+            await syncDirectory(publicC, env, this.keyDir, this.log);
+        }
+        catch (error) {
+            this.log.warn('directory: chain scan failed (%s) — using the cached directory', error instanceof Error ? error.message : String(error));
+        }
+        discovered = workerAddrs(loadDirectory(this.keyDir, env));
+        if (discovered.length === 0 && HARDCODED_SEEDS.length > 0) {
+            this.log.info('directory: empty — falling back to the configured bootstrap seed(s)');
+            discovered = await discoverWorkers(userNode, this.log);
+        }
+        const workers = [...new Set([...configuredWorkers, ...discovered])];
+        if (workers.length === 0) {
+            this.log.warn('no workers configured or discovered; /v1/models will stay empty');
+        }
+        // P4.9h: behavioural credit from escrow events. Boot refresh is
+        // fire-and-forget — an empty index only means offers show their own claim
+        // until the first scan lands.
+        const credit = new CreditTracker(publicC, env);
+        void credit.refresh().catch((error) => {
+            this.log.warn('credit: initial scan failed (%s)', error instanceof Error ? error.message : String(error));
+        });
+        const creditTimer = setInterval(() => {
+            void credit.refresh().catch(() => { });
+        }, 60_000);
+        // Funding facts for the user marketplace panel. The status page polls every
+        // few seconds, so the two reads are cached briefly and a failure only omits
+        // the balance instead of failing the whole status response.
+        const userWallet = walletAddress(this.vault.userKey());
+        let balanceCache = null;
+        const balances = async () => {
+            if (balanceCache != null && Date.now() - balanceCache.at < 20_000)
+                return balanceCache;
+            try {
+                const value = await readWalletBalances(publicC, env, userWallet);
+                balanceCache = { at: Date.now(), ...value };
+                return balanceCache;
+            }
+            catch (error) {
+                this.log.warn('balances: read failed (%s)', error instanceof Error ? error.message : String(error));
+                return null;
+            }
+        };
+        const bridge = await startOpenAiBridge({
+            workers,
+            port: this.config.port.get(),
+            env: this.config.env,
+            modeManager: this.modeManager,
+            getNode: async () => userNode,
+            userKey: () => this.vault.userKey(),
+            settle: this.config.settle,
+            onMode: (mode) => { this.scheduleMode(mode); },
+            credit: (wallets) => {
+                const out = new Map();
+                for (const wallet of wallets) {
+                    const snap = credit.snapshot(wallet);
+                    if (snap != null) {
+                        out.set(wallet.toLowerCase(), { score: snap.score, sessions: snap.sessions });
+                    }
+                }
+                return out;
+            },
+            log: line => this.log.info('%s', line),
+            status: async () => {
+                const value = await balances();
+                return {
+                    env,
+                    settle: this.config.settle,
+                    ...(value == null ? {} : { balances: { eth: value.eth.toString(), usdc: value.usdc.toString() } }),
+                };
+            },
+        });
+        this.log.info('openai bridge listening at %s', bridge.url);
+        this.stop = async () => {
+            clearInterval(creditTimer);
+            await bridge.close();
+        };
+    }
+    /** Worker half: the libp2p sidecar, its status dashboard, and Ollama. */
+    async startWorker() {
+        this.ollama = createOllamaSupervisor(this.config.ollamaHost, line => this.log.info('%s', line));
+        if (this.config.spawnOllama) {
+            const state = await this.ollama.ensureRunning();
+            if (state.running)
+                this.log.info('ollama %s ready at %s', state.version ?? '', state.host);
+            else {
+                this.log.warn('ollama is %s — the worker can start, but it cannot serve until onboarding finishes', state.installed ? `installed but not running (${state.error ?? 'no response'})` : 'not installed');
+            }
+        }
+        const workerKey = this.vault.workerKey();
+        const workerWallet = this.vault.addresses().worker;
+        let workerCatalog = loadCatalog(this.keyDir, this.config.catalog, this.log);
+        const paywall = this.config.paywall
+            ? createPaywall({
+                publicC: publicClientFor(this.config.env),
+                env: this.config.env,
+                worker: workerWallet,
+                log: this.log,
+            })
+            : undefined;
+        if (paywall == null) {
+            this.log.warn('paywall DISABLED — anyone who can dial this worker gets free inference');
+        }
+        const sidecar = await createSidecar({
+            paywall,
+            modeManager: this.modeManager,
+            source: createOllamaSource(this.config.ollamaHost),
+            // Serves open/1 sessions: chat messages plus tool schemas.
+            chatSource: createOllamaChatSource(this.config.ollamaHost),
+            listen: this.config.listen,
+            catalog: catalogOf(this.config.workerName, workerCatalog),
+            workerKey,
+            sessionEvents: (event) => {
+                if (event.type === 'session-error')
+                    this.log.warn('%s', event.message);
+                else if (event.type === 'session-end')
+                    this.log.info('session %s ended (%d tokens)', event.sessionId, event.tokens);
+            },
+        });
+        const bootAddrs = sidecar.peerAddrs();
+        // The settings page writes a per-machine opt-in; the deployment default
+        // (config.publishAddress) still forces it on when a release says so.
+        const publish = this.config.publishAddress || readPublishOptIn(this.keyDir);
+        const canPublish = publish && hasPublicAddr(bootAddrs);
+        if (canPublish) {
+            void registerBinding(this.config.env, this.keyDir, workerWallet, workerKey, sidecar.peerIdStr(), locatorOf(bootAddrs), this.log);
+        }
+        else {
+            // §39: a LAN-only peer cannot be dialed from the internet, so publishing
+            // it into the global directory only creates dead entries. It can still
+            // serve peers on the same network, and settlement is unaffected.
+            this.log.warn(hasPublicAddr(bootAddrs)
+                ? 'worker has a public address but publishAddress=false — staying out of the chain directory (privacy; enable publishAddress to be found)'
+                : 'worker has no public address (%s) — LAN-only: staying out of the chain directory; only peers on this network can dial it', hasPublicAddr(bootAddrs) ? undefined : bootAddrs.join(', '));
+            void retireStaleEntry(this.config.env, workerWallet, workerKey, sidecar.peerIdStr(), this.log);
+        }
+        void probeRpc(this.config.env, this.log);
+        this.statusServer = await startStatusServer(this.config.port.get(), () => {
+            const liveAddrs = sidecar.peerAddrs();
+            return {
+                role: this.modeManager.current().mode,
+                peerId: sidecar.peerIdStr(),
+                peerAddrs: liveAddrs,
+                wallet: workerWallet,
+                offers: catalogOf(this.config.workerName, workerCatalog).map(offer => ({
+                    addr: liveAddrs[0],
+                    offer: { ...toWire(offer), workerWallet },
+                })),
+                activeSessions: sidecar.activeSessions(),
+                reachable: hasPublicAddr(liveAddrs),
+                publishAddress: publish,
+            };
+        }, (catalog) => {
+            workerCatalog = entriesFromInput(catalog);
+            sidecar.setCatalog(catalogOf(this.config.workerName, workerCatalog));
+            persistCatalog(this.keyDir, workerCatalog, this.log);
+            this.log.info('catalog: saved %d offer(s) to %s', workerCatalog.length, join(this.keyDir, 'catalog.json'));
+        }, (mode) => { this.scheduleMode(mode); }, this.ollama, (next) => {
+            writePublishOptIn(this.keyDir, next);
+            this.log.info('directory publishing %s; restarting the worker half', next ? 'enabled' : 'disabled');
+            this.scheduleMode(this.modeManager.current().mode);
+        });
+        this.advertiseState = {
+            worker: sidecar,
+            wallet: workerWallet,
+            key: workerKey,
+            env: this.config.env,
+            publish,
+            applied: canPublish ? locatorOf(bootAddrs) : '',
+            pending: null,
+            retracting: false,
+        };
+        this.startAdvertiseWatch();
+        this.log.info('worker %s listening on %s', sidecar.peerIdStr(), sidecar.peerAddrs().join(', '));
+        this.log.info('worker dashboard at %s', this.statusServer.url);
+        this.stop = sidecar.stop;
+    }
+    /** Poll the announce set; advertise only after it has been stable for two
+     *  checks. A worker's listen addrs flap while interfaces come up (Wi-Fi,
+     *  VPN, sleep/wake) and every advertise is a chain write — this turns a
+     *  flap into zero transactions instead of a burst of them. */
+    startAdvertiseWatch() {
+        this.stopAdvertiseWatch();
+        const timer = setInterval(() => { void this.checkAdvertise(); }, 30_000);
+        timer.unref?.();
+        this.advertiseTimer = timer;
+    }
+    stopAdvertiseWatch() {
+        if (this.advertiseTimer != null)
+            clearInterval(this.advertiseTimer);
+        this.advertiseTimer = null;
+        this.advertiseState = null;
+    }
+    async checkAdvertise() {
+        const state = this.advertiseState;
+        if (state == null)
+            return;
+        let current = '';
+        try {
+            const addrs = state.worker.peerAddrs();
+            // Either LAN-only (public wifi, CGNAT, UPnP off) or publishing is off:
+            // nothing on-chain should point here. If it used to, retract once.
+            if (!state.publish || !hasPublicAddr(addrs)) {
+                state.pending = null;
+                if (state.applied !== '' && !state.retracting) {
+                    state.retracting = true;
+                    try {
+                        const tx = await deactivateWorker(walletClientFor(state.env, state.key), state.env);
+                        registryLog('deactivate wallet=' + state.wallet + ' tx=' + tx);
+                        this.log.info('worker lost public reachability — removed from the chain directory (tx %s)', tx);
+                        state.applied = '';
+                    }
+                    catch (error) {
+                        this.log.warn('worker retract failed (%s)', error instanceof Error ? error.message : String(error));
+                    }
+                    finally {
+                        state.retracting = false;
+                    }
+                }
+                return;
+            }
+            current = locatorOf(addrs);
+        }
+        catch {
+            return;
+        }
+        if (current === '' || current === state.applied) {
+            state.pending = null;
+            return;
+        }
+        // first sighting: remember it; second identical sighting: write
+        if (state.pending !== current) {
+            state.pending = current;
+            return;
+        }
+        try {
+            const tx = await advertiseWorker(walletClientFor(state.env, state.key), state.env, current);
+            state.applied = current;
+            state.pending = null;
+            registryLog('advertise wallet=' + state.wallet + ' tx=' + tx + ' locator=' + current);
+            this.log.info('worker locator updated on-chain (tx %s)', tx);
+        }
+        catch (error) {
+            state.pending = null;
+            this.log.warn('worker advertise failed (%s)', error instanceof Error ? error.message : String(error));
+        }
+    }
+    /** Stop the running halves without touching the lifetime mode ticker. */
+    async stopServices() {
+        this.stopAdvertiseWatch();
+        await Promise.resolve(this.statusServer?.close()).catch(() => { });
+        await Promise.resolve(this.stop?.()).catch(() => { });
+        await Promise.resolve(this.node?.stop()).catch(() => { });
+        this.ollama?.dispose();
+        this.ollama = null;
+    }
+    /** Shut down: stop services and the one lifetime mode ticker. */
+    async stopAll() {
+        this.stopModeTicker();
+        await this.stopServices();
+    }
+    /** Plugin-lifecycle shutdown alias. */
+    async dispose() {
+        await this.stopAll();
+    }
+}
+/** Seed peers are matchmakers: their peer list is the fallback worker set. */
+async function discoverWorkers(node, log) {
+    const peers = new Set();
+    await Promise.all(HARDCODED_SEEDS.map(async (seed) => {
+        try {
+            for (const peer of await fetchSeedPeers(node, seed))
+                peers.add(peer);
+        }
+        catch (error) {
+            log.warn('seed %s unreachable (%s)', seed, error instanceof Error ? error.message : String(error));
+        }
+    }));
+    return [...peers];
+}
+const REGISTRY_LOG = '/tmp/genkaku-registry.log';
+/** Best-effort registry diagnostics; a log failure never affects registration. */
+function registryLog(line) {
+    try {
+        appendFileSync(REGISTRY_LOG, new Date().toISOString() + ' ' + line + String.fromCharCode(10));
+    }
+    catch {
+        // best effort
+    }
+}
+const MODE_LOG = '/tmp/genkaku-mode.log';
+/** Best-effort mode-switch diagnostics; a log failure never affects reconfigure. */
+function modeLog(line) {
+    try {
+        appendFileSync(MODE_LOG, new Date().toISOString() + ' ' + line + String.fromCharCode(10));
+    }
+    catch {
+        // best effort
+    }
+}
+/** Best-effort WorkerRegistry pin: read/register failures only log, never stop serving. */
+const workerDigest = (peerId) => peerIdDigestOf(peerId);
+/** Boot-time cleanup: a worker that is now LAN-only may still own a directory
+ *  entry from a previous network. Retract it — but only when the on-chain
+ *  binding is OURS, never someone else's. */
+async function retireStaleEntry(env, wallet, workerKey, peerId, log) {
+    try {
+        const record = await readWorker(publicClientFor(env), env, wallet);
+        if (record == null || !record.active)
+            return;
+        if (record.peerId !== workerDigest(peerId))
+            return;
+        const tx = await deactivateWorker(walletClientFor(env, workerKey), env);
+        registryLog('retire wallet=' + wallet + ' tx=' + tx);
+        log.info('worker is LAN-only — stale directory entry retired (tx %s)', tx);
+    }
+    catch (error) {
+        registryLog('retire-error wallet=' + wallet + ' ' + (error instanceof Error ? error.message : String(error)));
+    }
+}
+async function registerBinding(env, keyDir, wallet, workerKey, peerId, locator, log) {
+    registryLog('start wallet=' + wallet + ' peer=' + peerId + ' locator=' + locator);
+    try {
+        const peerIdDigest = peerIdDigestOf(peerId);
+        const publicC = publicClientFor(env);
+        const existing = await readWorker(publicC, env, wallet);
+        registryLog('record wallet=' + wallet + ' peer=' + (existing == null ? 'none' : existing.peerId));
+        // active=false means a previous selfDeactivate tombstoned this wallet;
+        // advertise() would revert (NotRegistered), so re-register instead.
+        if (existing != null && existing.peerId === peerIdDigest && existing.active) {
+            // Binding is already right; only the address may have moved. The local
+            // directory cache answers this for free in the common case; the chain is
+            // only consulted when the cache has never seen this wallet.
+            const cached = loadDirectory(keyDir, env).entries
+                .find(entry => entry.wallet.toLowerCase() === wallet.toLowerCase());
+            const onChain = cached != null
+                ? []
+                : await readWorkerLocators(publicC, env, { wallet });
+            const advertised = cached?.locator ?? onChain[0]?.locator;
+            if (locator === '' || advertised === locator) {
+                registryLog('skip wallet=' + wallet + ' already pins ' + peerId);
+                log.info('worker registry already pins %s', peerId);
+                return;
+            }
+            const tx = await advertiseWorker(walletClientFor(env, workerKey), env, locator);
+            registryLog('advertise wallet=' + wallet + ' tx=' + tx);
+            log.info('worker locator published for %s (tx %s)', peerId, tx);
+            return;
+        }
+        registryLog('register wallet=' + wallet + ' ' + (existing == null ? 'new' : 'rebind ' + existing.peerId));
+        const tx = await registerWorkerWithLocator(walletClientFor(env, workerKey), env, {
+            peerIdDigest,
+            policyHash: policyHashOf(POLICY_VERSION),
+            locator,
+        });
+        registryLog('tx wallet=' + wallet + ' hash=' + tx);
+        log.info('worker registry bound %s to %s (tx %s)', peerId, wallet, tx);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        registryLog('error wallet=' + wallet + ' ' + message);
+        log.warn('worker registry registration failed (%s)', message);
+    }
+}
+/** Persisted catalog location inside the key directory. */
+function catalogPath(keyDir) {
+    return join(keyDir, 'catalog.json');
+}
+/** Read <keyDir>/catalog.json; a missing or invalid file falls back to config.catalog. */
+function loadCatalog(keyDir, fallback, log) {
+    const file = catalogPath(keyDir);
+    try {
+        const entries = normalizeCatalog(JSON.parse(readFileSync(file, 'utf8')));
+        if (entries != null)
+            return entries;
+        log.warn('catalog: %s is not a valid catalog — using config.catalog', file);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            log.warn('catalog: cannot read %s (%s) — using config.catalog', file, error instanceof Error ? error.message : String(error));
+        }
+    }
+    return fallback;
+}
+/** Accept the persisted array or a POST-shaped {catalog: [...]} object. */
+function normalizeCatalog(raw) {
+    const rows = Array.isArray(raw) ? raw : raw?.catalog;
+    if (!Array.isArray(rows))
+        return null;
+    const entries = [];
+    for (const row of rows) {
+        if (typeof row !== 'object' || row === null)
+            return null;
+        const model = row.model;
+        if (typeof model !== 'string' || model.trim() === '')
+            return null;
+        const rawPrice = row.pricePerHour;
+        const price = typeof rawPrice === 'number'
+            ? String(Math.round(rawPrice))
+            : typeof rawPrice === 'string' && /^\d+$/.test(rawPrice.trim()) ? rawPrice.trim() : null;
+        if (price == null)
+            return null;
+        const entry = { model: model.trim(), pricePerHour: price };
+        const city = row.city;
+        if (typeof city === 'string')
+            entry.city = city;
+        const creditScore = row.creditScore;
+        if (typeof creditScore === 'number')
+            entry.creditScore = creditScore;
+        const sessionsServed = row.sessionsServed;
+        if (typeof sessionsServed === 'number')
+            entry.sessionsServed = sessionsServed;
+        const maxConcurrent = row.maxConcurrent;
+        if (typeof maxConcurrent === 'number')
+            entry.maxConcurrent = maxConcurrent;
+        entries.push(entry);
+    }
+    return entries;
+}
+/** POST /genkaku/catalog input (micro-USDC numbers) → persisted entries. */
+function entriesFromInput(catalog) {
+    return catalog.map((row) => {
+        const entry = { model: row.model, pricePerHour: String(Math.round(row.pricePerHour)) };
+        if (typeof row.city === 'string')
+            entry.city = row.city;
+        if (typeof row.creditScore === 'number')
+            entry.creditScore = row.creditScore;
+        if (typeof row.sessionsServed === 'number')
+            entry.sessionsServed = row.sessionsServed;
+        if (typeof row.maxConcurrent === 'number')
+            entry.maxConcurrent = row.maxConcurrent;
+        return entry;
+    });
+}
+/** Best-effort catalog persistence; a write failure only logs. */
+function persistCatalog(keyDir, entries, log) {
+    try {
+        mkdirSync(keyDir, { recursive: true });
+        writeFileSync(catalogPath(keyDir), JSON.stringify(entries, null, 2) + '\n');
+    }
+    catch (error) {
+        log.warn('catalog: persist failed (%s)', error instanceof Error ? error.message : String(error));
+    }
+}
+/** Catalog rows → the Offer shape createSidecar publishes (wallet added there). */
+function catalogOf(workerName, entries) {
+    return entries.map(entry => ({
+        proto: 'offers/0',
+        workerName,
+        model: entry.model,
+        pricePerHour: BigInt(entry.pricePerHour),
+        city: entry.city,
+        creditScore: entry.creditScore ?? 50,
+        sessionsServed: entry.sessionsServed ?? 0,
+        maxConcurrent: entry.maxConcurrent,
+    }));
+}
+/** Best-effort local Ollama service; a failed spawn leaves an existing daemon alone. */
+//# sourceMappingURL=runtime.js.map

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@genkaku/dsh-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "DeepSeek Harness adapter layer for the GenKaKu protocol runtime",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@deepseek-ai/cosmokit": "1.9.0",
+    "@deepseek-ai/schemastery": "^3.19.0",
+    "@genkaku/protocol": "0.1.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.1.0",
+    "@deepseek-ai/dsh-settings": "0.2.2-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.1.0",
+    "@deepseek-ai/dsh-settings": "0.2.2-rc.1",
+    "libp2p": "1.9.4",
+    "viem": "2.57.16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mlaimail77/genkaku-plugin.git",
+    "directory": "packages/dsh-runtime"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "GenKaKu Labs",
+  "homepage": "https://staging.genkaku.app",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "p2p",
+    "libp2p",
+    "ollama",
+    "usdc",
+    "base"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.