@xrkseek/harness 0.6.21 → 0.7.0-rc.1

package/node_modules/@xrkseek/xrk-invariants/lib/types/index.js

@@ -0,0 +1,148 @@
+/**
+ * Configurable registry for package-owned runtime invariant contributions.
+ * Every workspace package registers checks from a `./invariant` companion;
+ * ordinary package entrypoints stay independent of diagnostics.
+ *
+ * @module @xrkseek/xrk-invariants
+ */
+import { Service } from '@xrkseek/cordis';
+import z from '@xrkseek/schemastery';
+/** Thrown when a package-owned runtime invariant is violated. */
+export class InvariantError extends Error {
+    /** Stable machine-readable invariant failure code. */
+    code = 'INVARIANT';
+    /** Full npm package name that owns the violated invariant. */
+    packageName;
+    /**
+     * Construct a package-attributed invariant failure.
+     * @param packageName - full npm package name that registered the check.
+     * @param message - violated contract, without the standard error prefix.
+     */
+    constructor(packageName, message) {
+        super(`invariant violated by "${packageName}": ${message}`);
+        this.name = 'InvariantError';
+        this.packageName = packageName;
+    }
+}
+/** Compile and validate one package-filter list. */
+function compilePatterns(field, values) {
+    const seen = new Set();
+    return values.map((value) => {
+        if (value.length === 0 || value.trim() !== value) {
+            throw new Error(`invariants: ${field} entries must be non-blank and have no surrounding whitespace`);
+        }
+        if (seen.has(value)) {
+            throw new Error(`invariants: ${field} contains duplicate regex ${JSON.stringify(value)}`);
+        }
+        seen.add(value);
+        try {
+            return new RegExp(value);
+        }
+        catch (cause) {
+            throw new Error(`invariants: ${field} contains invalid regex ${JSON.stringify(value)}`, { cause });
+        }
+    });
+}
+/** Package-owned invariant registry with global and regex-based selection. */
+export class InvariantRegistry extends Service {
+    static Config = z.object({
+        enabled: z.boolean().default(true),
+        package_allowlist: z.array(z.string()).default([]),
+        package_blocklist: z.array(z.string()).default([]),
+    });
+    enabled;
+    ownerCtx;
+    packageAllowlist;
+    packageBlocklist;
+    registrations = new Set();
+    /**
+     * Create and install the invariant registry.
+     * @param ctx - Cordis context that owns the service.
+     * @param config - global enablement and package-name regex filters.
+     */
+    constructor(ctx, config = {}) {
+        super(ctx, 'invariants');
+        this.ownerCtx = ctx;
+        this.enabled = config.enabled ?? true;
+        this.packageAllowlist = compilePatterns('package_allowlist', config.package_allowlist ?? []);
+        this.packageBlocklist = compilePatterns('package_blocklist', config.package_blocklist ?? []);
+    }
+    /** Return whether one full package name passes the configured filters. */
+    selected(packageName) {
+        if (!this.enabled)
+            return false;
+        if (this.packageAllowlist.length > 0
+            && !this.packageAllowlist.some(pattern => pattern.test(packageName)))
+            return false;
+        return !this.packageBlocklist.some(pattern => pattern.test(packageName));
+    }
+    /**
+     * Register one package's invariant installer. The package name is reserved
+     * even when filtering disables its checks. Enabled installers run in a child
+     * fiber; failure disposes that fiber and releases the reservation.
+     * @param packageName - full npm package name that owns the contribution.
+     * @param installer - listener or startup-check installer for the child context.
+     * @returns an effect-scoped disposer for the registration.
+     */
+    register(packageName, installer) {
+        if (packageName.length === 0 || packageName.trim() !== packageName || /\s/.test(packageName)) {
+            throw new Error('invariants: packageName must be non-blank and contain no whitespace');
+        }
+        if (this.registrations.has(packageName)) {
+            throw new Error(`invariants: package "${packageName}" is already registered`);
+        }
+        // Service method tracing binds `this.ctx` to the caller. This explicit
+        // origin keeps registrations and their child fibers owned by the service;
+        // companion disposal is covered independently by the returned disposer.
+        const ctx = this.ownerCtx;
+        const registrations = this.registrations;
+        registrations.add(packageName);
+        let registration;
+        try {
+            registration = ctx.effect(async () => {
+                if (!this.selected(packageName)) {
+                    return () => {
+                        registrations.delete(packageName);
+                    };
+                }
+                const installInvariant = (childCtx) => (installer(childCtx, (message) => {
+                    throw new InvariantError(packageName, message);
+                }));
+                try {
+                    const child = ctx.plugin(installer.inject === undefined
+                        ? installInvariant
+                        : Object.assign(installInvariant, { inject: installer.inject }));
+                    try {
+                        await child;
+                    }
+                    catch (error) {
+                        await child.dispose();
+                        throw error;
+                    }
+                    return async () => {
+                        try {
+                            await child.dispose();
+                        }
+                        finally {
+                            registrations.delete(packageName);
+                        }
+                    };
+                }
+                catch (error) {
+                    registrations.delete(packageName);
+                    throw error;
+                }
+            }, `invariants.register(${JSON.stringify(packageName)})`);
+        }
+        catch (error) {
+            registrations.delete(packageName);
+            throw error;
+        }
+        // Cordis attaches setup thenability and async teardown to this callable;
+        // the service contract intentionally exposes only the conventional disposer.
+        // oxlint-disable-next-line typescript/no-misused-promises -- the extra runtime shape stays private.
+        return registration;
+    }
+}
+export default InvariantRegistry;
+//# sourceMappingURL=index.js.map

package/node_modules/@xrkseek/xrk-invariants/lib/types/invariant.js

@@ -0,0 +1,22 @@
+/**
+ * Package-owned invariant companion for `@xrkseek/xrk-invariants`.
+ * @module @xrkseek/xrk-invariants/invariant
+ */
+const PACKAGE_NAME = '@xrkseek/xrk-invariants';
+/** Cordis companion plugin name. */
+export const name = 'invariants-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/**
+ * No runtime invariant: registration ownership and child lifecycle are the service's mutation
+ * boundary itself; observing them from the same registry would only duplicate its implementation.
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */
+//# sourceMappingURL=invariant.js.map

package/node_modules/@xrkseek/xrk-invariants/package.json

@@ -25,6 +25,7 @@
   "files": [
     "lib/index.js",
     "lib/invariant.js",
+    "lib/types/**/*.js",
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",

package/node_modules/@xrkseek/xrk-llm/lib/index.js

@@ -1 +1 @@
-export * from './types/index.js'
+export * from "./types/index.js";

package/node_modules/@xrkseek/xrk-llm/lib/invariant.js

@@ -0,0 +1 @@
+export * from "./types/invariant.js";

package/node_modules/@xrkseek/xrk-llm/lib/types/index.js

@@ -412,6 +412,10 @@ export class LlmRuntime extends Service {
                 ...model.name === undefined ? {} : { name: model.name },
                 ...model.contextWindow === undefined ? {} : { contextWindow: model.contextWindow },
                 ...model.maxTokens === undefined ? {} : { maxTokens: model.maxTokens },
+                ...model.inputModalities === undefined || model.inputModalities.length === 0
+                    ? {}
+                    : { inputModalities: [...model.inputModalities] },
+                ...model.reasoning === undefined ? {} : { reasoning: model.reasoning },
             });
         }
         return models;

package/node_modules/@xrkseek/xrk-llm/lib/types/types.d.ts

@@ -227,6 +227,17 @@ export interface LlmDiscoveredModel {
     contextWindow?: number;
     /** Maximum output tokens, when disclosed. */
     maxTokens?: number;
+    /** Inputs the model accepts, when the listing (or the catalog) says. */
+    inputModalities?: readonly ('text' | 'image')[];
+    /** Thinking menu when the endpoint advertises one. */
+    reasoning?: {
+        readonly efforts: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly description?: string;
+        }[];
+        readonly defaultEffort?: string;
+    };
 }
 /** One adapter-discovered model; catalog membership is advisory, not request validation. */
 export interface LlmModelInfo {

package/node_modules/@xrkseek/xrk-permission-presets/lib/index.js

@@ -1 +1 @@
-export * from './types/index.js'
+export * from "./types/index.js";

package/node_modules/@xrkseek/xrk-permission-presets/lib/invariant.js

@@ -0,0 +1 @@
+export * from "./types/invariant.js";

package/node_modules/@xrkseek/xrk-scope/lib/index.js

@@ -0,0 +1 @@
+export * from "./types/index.js";

package/node_modules/@xrkseek/xrk-scope/lib/types/index.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Agent-scoped registration tables and event-dispatch carriers.
+ *
+ * Host packages (`xrk-tools`, `xrk-commands`, `xrk-session`, `xrk-agent`)
+ * register through `agent.ctx` and dispatch with a {@link scopeTarget}
+ * carrier so tagged listeners only hear their own agent.
+ *
+ * @module @xrkseek/xrk-scope
+ */
+import { Context } from '@xrkseek/cordis';
+/** Object identity used as a scope key (typically a live Agent). */
+export type ScopeKey = object;
+/** One contribution table that can report whether it still owns anything. */
+export interface ScopeLayer {
+    /** Whether every contribution in this layer is empty. */
+    isEmpty(): boolean;
+}
+/** Subject object carrying the Cordis listener filter for one scope key. */
+export type Scoped<T> = T & {
+    [Context.filter]: (ctx: Context) => boolean;
+};
+/**
+ * Read the nearest scope key on a context (own or inherited via `extend`).
+ * @param ctx - any Cordis context.
+ * @returns the tagged key, or `undefined` on a plain root context.
+ */
+export declare function scopeOf(ctx: Context): ScopeKey | undefined;
+/**
+ * Child context tagged with `key` and a dispatch filter: untagged listeners
+ * hear every event; tagged listeners hear only a matching key.
+ * @param ctx - parent context.
+ * @param key - owning agent (or other object identity).
+ * @returns the tagged child context.
+ */
+export declare function isolateScope(ctx: Context, key: ScopeKey): Context;
+/**
+ * Attach (or replace) the Cordis listener filter on `source` so emits that
+ * pass this object as `thisArg` are scope-filtered.
+ * @param source - the dispatch subject (agent, session, or service).
+ * @param key - the owning scope, or `undefined` for untagged (global) dispatch.
+ * @returns `source` with the filter installed.
+ */
+export declare function scopeTarget<T extends object>(source: T, key: ScopeKey | undefined): Scoped<T>;
+/** Named map that rejects duplicate keys with a caller-supplied error. */
+export declare class NamedEntries<T> {
+    private readonly duplicate;
+    private readonly items;
+    /**
+     * @param duplicate - factory for the error thrown when `insert` collides.
+     */
+    constructor(duplicate: (name: string) => Error);
+    /**
+     * Insert `name` → `value`. Throws when the name is already live.
+     * @param name - unique key inside this layer.
+     * @param value - registered value.
+     * @returns disposer that removes this exact entry.
+     */
+    insert(name: string, value: T): () => void;
+    /** @returns whether no names remain. */
+    isEmpty(): boolean;
+    /** @returns live `[name, value]` pairs. */
+    entries(): IterableIterator<[string, T]>;
+    /** @returns live values. */
+    values(): IterableIterator<T>;
+}
+/** Ordered bag of unnamed contributions (restrictions, guards). */
+export declare class AnonymousEntries<T> {
+    private seq;
+    private readonly items;
+    /**
+     * Append one contribution.
+     * @param value - the live entry.
+     * @returns disposer that removes this exact entry.
+     */
+    append(value: T): () => void;
+    /** @returns whether no contributions remain. */
+    isEmpty(): boolean;
+    /** @returns live values in insertion order. */
+    values(): IterableIterator<T>;
+}
+/**
+ * Global + per-scope contribution layers. Registrations go through
+ * {@link ScopedLayers.effect} so they unwind with the calling fiber.
+ */
+export declare class ScopedLayers<L extends ScopeLayer> {
+    private readonly create;
+    private readonly onChange;
+    readonly global: L;
+    private readonly scoped;
+    private readonly parents;
+    /**
+     * @param create - mint one layer for `scope` (`undefined` = global).
+     * @param onChange - fire after a registration is added or removed.
+     */
+    constructor(create: (scope: ScopeKey | undefined) => L, onChange: () => void);
+    /**
+     * Apply `register` against the layer selected by `scopeOf(ctx)`.
+     * @param ctx - calling context (plain = global; tagged = that scope).
+     * @param register - mutates the layer and returns its inner disposer.
+     * @param opts - optional Cordis effect label.
+     * @returns the exact `ctx.effect` disposer.
+     */
+    effect(ctx: Context, register: (layer: L) => () => void, opts?: {
+        label?: string;
+    }): () => void;
+    /**
+     * Layers from farthest ancestor to the exact scope, always starting with
+     * the global layer. Missing (never-contributed) scoped layers are omitted.
+     * @param scope - viewing agent, or `undefined` for the global view.
+     * @returns the ordered chain.
+     */
+    chainLayers(scope?: ScopeKey): L[];
+    /**
+     * The layer this scope owns, or `undefined` until it contributes.
+     * The global view returns {@link global}.
+     * @param scope - viewing agent, or `undefined` for global.
+     */
+    peek(scope?: ScopeKey): L | undefined;
+    /**
+     * Merge named tables along {@link chainLayers}: farther names first, nearer
+     * same-name entries shadow.
+     * @param scope - viewing agent.
+     * @param pick - select the named table on one layer.
+     */
+    merge<T>(scope: ScopeKey | undefined, pick: (layer: L) => NamedEntries<T>): Map<string, T>;
+    private layerOf;
+    private rememberParent;
+}
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@xrkseek/xrk-scope/lib/types/index.js

@@ -0,0 +1,243 @@
+/**
+ * Agent-scoped registration tables and event-dispatch carriers.
+ *
+ * Host packages (`xrk-tools`, `xrk-commands`, `xrk-session`, `xrk-agent`)
+ * register through `agent.ctx` and dispatch with a {@link scopeTarget}
+ * carrier so tagged listeners only hear their own agent.
+ *
+ * @module @xrkseek/xrk-scope
+ */
+import { Context } from '@xrkseek/cordis';
+/** Context tag written by {@link isolateScope}. */
+const kScope = Symbol('xrk.scope');
+/**
+ * Read the nearest scope key on a context (own or inherited via `extend`).
+ * @param ctx - any Cordis context.
+ * @returns the tagged key, or `undefined` on a plain root context.
+ */
+export function scopeOf(ctx) {
+    return ctx[kScope];
+}
+/**
+ * Child context tagged with `key` and a dispatch filter: untagged listeners
+ * hear every event; tagged listeners hear only a matching key.
+ * @param ctx - parent context.
+ * @param key - owning agent (or other object identity).
+ * @returns the tagged child context.
+ */
+export function isolateScope(ctx, key) {
+    return ctx.extend({
+        [kScope]: key,
+        [Context.filter](listenerCtx) {
+            const tag = scopeOf(listenerCtx);
+            return tag === undefined || tag === key;
+        },
+    });
+}
+/**
+ * Attach (or replace) the Cordis listener filter on `source` so emits that
+ * pass this object as `thisArg` are scope-filtered.
+ * @param source - the dispatch subject (agent, session, or service).
+ * @param key - the owning scope, or `undefined` for untagged (global) dispatch.
+ * @returns `source` with the filter installed.
+ */
+export function scopeTarget(source, key) {
+    const carrier = source;
+    Object.defineProperty(carrier, Context.filter, {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value(listenerCtx) {
+            const tag = scopeOf(listenerCtx);
+            return tag === undefined || tag === key;
+        },
+    });
+    return carrier;
+}
+/** Named map that rejects duplicate keys with a caller-supplied error. */
+export class NamedEntries {
+    duplicate;
+    items = new Map();
+    /**
+     * @param duplicate - factory for the error thrown when `insert` collides.
+     */
+    constructor(duplicate) {
+        this.duplicate = duplicate;
+    }
+    /**
+     * Insert `name` → `value`. Throws when the name is already live.
+     * @param name - unique key inside this layer.
+     * @param value - registered value.
+     * @returns disposer that removes this exact entry.
+     */
+    insert(name, value) {
+        if (this.items.has(name))
+            throw this.duplicate(name);
+        this.items.set(name, value);
+        return () => { this.items.delete(name); };
+    }
+    /** @returns whether no names remain. */
+    isEmpty() {
+        return this.items.size === 0;
+    }
+    /** @returns live `[name, value]` pairs. */
+    entries() {
+        return this.items.entries();
+    }
+    /** @returns live values. */
+    values() {
+        return this.items.values();
+    }
+}
+/** Ordered bag of unnamed contributions (restrictions, guards). */
+export class AnonymousEntries {
+    seq = 0;
+    items = new Map();
+    /**
+     * Append one contribution.
+     * @param value - the live entry.
+     * @returns disposer that removes this exact entry.
+     */
+    append(value) {
+        const id = this.seq;
+        this.seq += 1;
+        this.items.set(id, value);
+        return () => { this.items.delete(id); };
+    }
+    /** @returns whether no contributions remain. */
+    isEmpty() {
+        return this.items.size === 0;
+    }
+    /** @returns live values in insertion order. */
+    values() {
+        return this.items.values();
+    }
+}
+/**
+ * Global + per-scope contribution layers. Registrations go through
+ * {@link ScopedLayers.effect} so they unwind with the calling fiber.
+ */
+export class ScopedLayers {
+    create;
+    onChange;
+    global;
+    scoped = new Map();
+    parents = new WeakMap();
+    /**
+     * @param create - mint one layer for `scope` (`undefined` = global).
+     * @param onChange - fire after a registration is added or removed.
+     */
+    constructor(create, onChange) {
+        this.create = create;
+        this.onChange = onChange;
+        this.global = create(undefined);
+    }
+    /**
+     * Apply `register` against the layer selected by `scopeOf(ctx)`.
+     * @param ctx - calling context (plain = global; tagged = that scope).
+     * @param register - mutates the layer and returns its inner disposer.
+     * @param opts - optional Cordis effect label.
+     * @returns the exact `ctx.effect` disposer.
+     */
+    effect(ctx, register, opts) {
+        const scope = scopeOf(ctx);
+        this.rememberParent(ctx, scope);
+        const run = () => {
+            const layer = this.layerOf(scope);
+            const inner = register(layer);
+            this.onChange();
+            return () => {
+                inner();
+                if (scope !== undefined && layer.isEmpty())
+                    this.scoped.delete(scope);
+                this.onChange();
+            };
+        };
+        const label = opts?.label;
+        return label === undefined ? ctx.effect(run) : ctx.effect(run, label);
+    }
+    /**
+     * Layers from farthest ancestor to the exact scope, always starting with
+     * the global layer. Missing (never-contributed) scoped layers are omitted.
+     * @param scope - viewing agent, or `undefined` for the global view.
+     * @returns the ordered chain.
+     */
+    chainLayers(scope) {
+        const chain = [this.global];
+        if (scope === undefined)
+            return chain;
+        const keys = [];
+        const seen = new Set();
+        let current = scope;
+        while (current !== undefined && !seen.has(current)) {
+            seen.add(current);
+            keys.push(current);
+            current = this.parents.get(current);
+        }
+        keys.reverse();
+        for (const key of keys) {
+            const layer = this.scoped.get(key);
+            if (layer !== undefined)
+                chain.push(layer);
+        }
+        return chain;
+    }
+    /**
+     * The layer this scope owns, or `undefined` until it contributes.
+     * The global view returns {@link global}.
+     * @param scope - viewing agent, or `undefined` for global.
+     */
+    peek(scope) {
+        if (scope === undefined)
+            return this.global;
+        return this.scoped.get(scope);
+    }
+    /**
+     * Merge named tables along {@link chainLayers}: farther names first, nearer
+     * same-name entries shadow.
+     * @param scope - viewing agent.
+     * @param pick - select the named table on one layer.
+     */
+    merge(scope, pick) {
+        const merged = new Map();
+        for (const layer of this.chainLayers(scope)) {
+            for (const [name, value] of pick(layer).entries())
+                merged.set(name, value);
+        }
+        return merged;
+    }
+    layerOf(scope) {
+        if (scope === undefined)
+            return this.global;
+        const existing = this.scoped.get(scope);
+        if (existing !== undefined)
+            return existing;
+        const created = this.create(scope);
+        this.scoped.set(scope, created);
+        return created;
+    }
+    rememberParent(ctx, scope) {
+        if (scope === undefined || this.parents.has(scope))
+            return;
+        const parentKey = parentScopeOf(ctx, scope);
+        if (parentKey !== undefined)
+            this.parents.set(scope, parentKey);
+    }
+}
+/** Walk fiber parents for a nearer-then-farther different scope tag. */
+function parentScopeOf(ctx, self) {
+    let current = ctx.fiber.parent;
+    const seen = new Set();
+    while (current !== undefined && !seen.has(current)) {
+        seen.add(current);
+        const key = scopeOf(current);
+        if (key !== undefined && key !== self)
+            return key;
+        const parent = current.fiber.parent;
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return undefined;
+}
+//# sourceMappingURL=index.js.map

package/node_modules/@xrkseek/xrk-scope/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@xrkseek/xrk-scope",
+  "description": "Agent-scoped registration tables and dispatch carriers for the DeepSeek Harness",
+  "version": "0.1.0-rc.8",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xrkseek/XRK-harness.git",
+    "directory": "packages/core/scope"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@xrkseek/cordis": "workspace:^"
+  },
+  "devDependencies": {
+    "@xrkseek/cordis": "workspace:^"
+  },
+  "private": true
+}

package/node_modules/@xrkseek/xrk-session/lib/index.js

@@ -1 +1 @@
-export * from './types/index.js'
+export * from "./types/index.js";

package/node_modules/@xrkseek/xrk-session/lib/invariant.js

@@ -0,0 +1 @@
+export * from "./types/invariant.js";

package/node_modules/@xrkseek/xrk-session-projection/lib/index.js

@@ -1 +1 @@
-export * from './types/index.js'
+export * from "./types/index.js";

package/node_modules/@xrkseek/xrk-session-projection/lib/invariant.js

@@ -0,0 +1 @@
+export * from "./types/invariant.js";