@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

package/dist/harness/circuitBreaker.d.ts

@@ -0,0 +1,51 @@
+/**
+ * CircuitBreaker — closed/open/half-open state machine for protecting
+ * downstream calls from cascading failures.
+ *
+ * States:
+ *  - closed   — requests pass through normally; failures are counted.
+ *  - open     — all requests are rejected immediately; after `resetTimeoutMs`
+ *               the breaker transitions to half-open.
+ *  - half-open — a single probe request is allowed; success resets to closed,
+ *                failure reopens.
+ */
+export type CircuitState = 'closed' | 'open' | 'half-open';
+export interface CircuitBreakerOptions {
+    /** Number of consecutive failures before opening the circuit. Default: 5. */
+    failureThreshold?: number;
+    /** Time (ms) the circuit stays open before transitioning to half-open. Default: 30 000. */
+    resetTimeoutMs?: number;
+}
+export interface CircuitBreakerSnapshot {
+    state: CircuitState;
+    failureCount: number;
+    lastFailureAt: number | null;
+    lastSuccessAt: number | null;
+}
+export declare class CircuitBreaker {
+    private state;
+    private failureCount;
+    private lastFailureAt;
+    private lastSuccessAt;
+    private openedAt;
+    private readonly failureThreshold;
+    private readonly resetTimeoutMs;
+    constructor(options?: CircuitBreakerOptions);
+    /** Return a point-in-time snapshot of the breaker state. */
+    getState(now?: number): CircuitBreakerSnapshot;
+    /** Whether the circuit currently allows requests through. */
+    isAllowed(now?: number): boolean;
+    /** Record a successful call. Resets the breaker to closed. */
+    recordSuccess(now?: number): void;
+    /** Record a failed call. Opens the circuit when the threshold is reached. */
+    recordFailure(now?: number): void;
+    /** Force the breaker into the closed state (e.g. manual override). */
+    reset(): void;
+    /**
+     * Execute `fn` through the circuit breaker.
+     * Throws if the circuit is open.
+     */
+    execute<T>(fn: () => Promise<T>, now?: number): Promise<T>;
+    private maybeTick;
+}
+//# sourceMappingURL=circuitBreaker.d.ts.map

package/dist/harness/circuitBreaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuitBreaker.d.ts","sourceRoot":"","sources":["../../src/harness/circuitBreaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D,MAAM,WAAW,qBAAqB;IACpC,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,2FAA2F;IAC3F,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAMD,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,QAAQ,CAAuB;IAEvC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,OAAO,CAAC,EAAE,qBAAqB;IAS3C,4DAA4D;IAC5D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,sBAAsB;IAW9C,6DAA6D;IAC7D,SAAS,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO;IAShC,8DAA8D;IAC9D,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAQjC,6EAA6E;IAC7E,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAWjC,sEAAsE;IACtE,KAAK,IAAI,IAAI;IAUb;;;OAGG;IACG,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAoBhE,OAAO,CAAC,SAAS;CAQlB"}

package/dist/harness/circuitBreaker.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * CircuitBreaker — closed/open/half-open state machine for protecting
+ * downstream calls from cascading failures.
+ *
+ * States:
+ *  - closed   — requests pass through normally; failures are counted.
+ *  - open     — all requests are rejected immediately; after `resetTimeoutMs`
+ *               the breaker transitions to half-open.
+ *  - half-open — a single probe request is allowed; success resets to closed,
+ *                failure reopens.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = void 0;
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+class CircuitBreaker {
+    state = 'closed';
+    failureCount = 0;
+    lastFailureAt = null;
+    lastSuccessAt = null;
+    openedAt = null;
+    failureThreshold;
+    resetTimeoutMs;
+    constructor(options) {
+        this.failureThreshold = options?.failureThreshold ?? 5;
+        this.resetTimeoutMs = options?.resetTimeoutMs ?? 30_000;
+    }
+    // -------------------------------------------------------------------------
+    // Query
+    // -------------------------------------------------------------------------
+    /** Return a point-in-time snapshot of the breaker state. */
+    getState(now) {
+        // Check for automatic transition from open → half-open
+        this.maybeTick(now);
+        return {
+            state: this.state,
+            failureCount: this.failureCount,
+            lastFailureAt: this.lastFailureAt,
+            lastSuccessAt: this.lastSuccessAt,
+        };
+    }
+    /** Whether the circuit currently allows requests through. */
+    isAllowed(now) {
+        this.maybeTick(now);
+        return this.state !== 'open';
+    }
+    // -------------------------------------------------------------------------
+    // Recording outcomes
+    // -------------------------------------------------------------------------
+    /** Record a successful call. Resets the breaker to closed. */
+    recordSuccess(now) {
+        const ts = now ?? Date.now();
+        this.lastSuccessAt = ts;
+        this.failureCount = 0;
+        this.state = 'closed';
+        this.openedAt = null;
+    }
+    /** Record a failed call. Opens the circuit when the threshold is reached. */
+    recordFailure(now) {
+        const ts = now ?? Date.now();
+        this.lastFailureAt = ts;
+        this.failureCount++;
+        if (this.state === 'half-open' || this.failureCount >= this.failureThreshold) {
+            this.state = 'open';
+            this.openedAt = ts;
+        }
+    }
+    /** Force the breaker into the closed state (e.g. manual override). */
+    reset() {
+        this.state = 'closed';
+        this.failureCount = 0;
+        this.openedAt = null;
+    }
+    // -------------------------------------------------------------------------
+    // Execute with protection
+    // -------------------------------------------------------------------------
+    /**
+     * Execute `fn` through the circuit breaker.
+     * Throws if the circuit is open.
+     */
+    async execute(fn, now) {
+        const ts = now ?? Date.now();
+        if (!this.isAllowed(ts)) {
+            throw new Error('Circuit breaker is open — request rejected');
+        }
+        try {
+            const result = await fn();
+            this.recordSuccess(ts);
+            return result;
+        }
+        catch (err) {
+            this.recordFailure(ts);
+            throw err;
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Internal
+    // -------------------------------------------------------------------------
+    maybeTick(now) {
+        if (this.state === 'open' && this.openedAt != null) {
+            const ts = now ?? Date.now();
+            if (ts - this.openedAt >= this.resetTimeoutMs) {
+                this.state = 'half-open';
+            }
+        }
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;

package/dist/harness/concurrentEffects.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Concurrent Effects Execution (GAP-PAR-001).
+ *
+ * Provides concurrency-limited execution of effect groups using a
+ * semaphore pattern. Complements the SDK-level concurrentExecution.ts
+ * with platform-layer policies and group execution.
+ */
+/** Policy controlling how concurrent effects are dispatched. */
+export interface ConcurrencyPolicy {
+    /** Maximum number of effects to execute simultaneously. */
+    maxConcurrency: number;
+    /**
+     * Whether to continue executing remaining effects when one fails.
+     * Default: true (best-effort).
+     */
+    continueOnFailure?: boolean;
+}
+/** Result of a single effect execution within a concurrent group. */
+export interface ConcurrentEffectResult<T = unknown> {
+    /** Index within the group. */
+    index: number;
+    /** Whether the execution succeeded. */
+    status: "fulfilled" | "rejected";
+    /** Resolved value, if successful. */
+    value?: T;
+    /** Error reason, if rejected. */
+    reason?: unknown;
+}
+/**
+ * Execute a group of effect tasks concurrently, respecting the
+ * concurrency limit specified in the policy.
+ *
+ * Each effect is represented as an async function. The semaphore ensures
+ * at most `policy.maxConcurrency` effects run simultaneously.
+ *
+ * Returns settled results (never throws).
+ */
+export declare function executeConcurrentGroup<T>(effects: Array<() => Promise<T>>, policy: ConcurrencyPolicy): Promise<Array<ConcurrentEffectResult<T>>>;
+//# sourceMappingURL=concurrentEffects.d.ts.map

package/dist/harness/concurrentEffects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concurrentEffects.d.ts","sourceRoot":"","sources":["../../src/harness/concurrentEffects.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,qEAAqE;AACrE,MAAM,WAAW,sBAAsB,CAAC,CAAC,GAAG,OAAO;IACjD,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,MAAM,EAAE,WAAW,GAAG,UAAU,CAAC;IACjC,qCAAqC;IACrC,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,iCAAiC;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAwCD;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC5C,OAAO,EAAE,KAAK,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,EAChC,MAAM,EAAE,iBAAiB,GACxB,OAAO,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAoC3C"}

package/dist/harness/concurrentEffects.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Concurrent Effects Execution (GAP-PAR-001).
+ *
+ * Provides concurrency-limited execution of effect groups using a
+ * semaphore pattern. Complements the SDK-level concurrentExecution.ts
+ * with platform-layer policies and group execution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeConcurrentGroup = executeConcurrentGroup;
+// ---------------------------------------------------------------------------
+// Semaphore
+// ---------------------------------------------------------------------------
+/**
+ * Simple counting semaphore for concurrency control.
+ * Limits the number of concurrent Promise executions.
+ */
+class Semaphore {
+    limit;
+    current = 0;
+    waiters = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async acquire() {
+        if (this.current < this.limit) {
+            this.current += 1;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    release() {
+        const next = this.waiters.shift();
+        if (next) {
+            next();
+        }
+        else {
+            this.current -= 1;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Core API
+// ---------------------------------------------------------------------------
+/**
+ * Execute a group of effect tasks concurrently, respecting the
+ * concurrency limit specified in the policy.
+ *
+ * Each effect is represented as an async function. The semaphore ensures
+ * at most `policy.maxConcurrency` effects run simultaneously.
+ *
+ * Returns settled results (never throws).
+ */
+async function executeConcurrentGroup(effects, policy) {
+    if (effects.length === 0)
+        return [];
+    const concurrency = Math.max(1, Math.min(effects.length, policy.maxConcurrency));
+    const semaphore = new Semaphore(concurrency);
+    const continueOnFailure = policy.continueOnFailure ?? true;
+    const results = new Array(effects.length);
+    let aborted = false;
+    const tasks = effects.map(async (effect, index) => {
+        if (aborted) {
+            results[index] = { index, status: "rejected", reason: new Error("Aborted due to prior failure") };
+            return;
+        }
+        await semaphore.acquire();
+        try {
+            if (aborted) {
+                results[index] = { index, status: "rejected", reason: new Error("Aborted due to prior failure") };
+                return;
+            }
+            const value = await effect();
+            results[index] = { index, status: "fulfilled", value };
+        }
+        catch (error) {
+            results[index] = { index, status: "rejected", reason: error };
+            if (!continueOnFailure) {
+                aborted = true;
+            }
+        }
+        finally {
+            semaphore.release();
+        }
+    });
+    await Promise.all(tasks);
+    return results;
+}

package/dist/harness/effectRouting.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Effect routing — pattern-matched routing of effects to harness/model
+ * targets with priority-based cascading rules (GAP-AGENT-003).
+ */
+export interface RoutingRule {
+    id: string;
+    /** Glob-like pattern matching effect kind and/or labels (e.g. "shell:*", "agent:deploy*"). */
+    pattern: string;
+    /** Target harness or model identifier to route to. */
+    target: string;
+    /** Higher priority rules are evaluated first (descending). Default: 0. */
+    priority: number;
+    /** Optional condition expression for context-aware routing. */
+    condition?: string;
+}
+export interface RoutingResult {
+    rule: RoutingRule;
+    target: string;
+}
+export type RoutingContext = Record<string, string | number | boolean>;
+/**
+ * Evaluate a simple condition expression against a context.
+ *
+ * Supported forms:
+ *  - `key == value`
+ *  - `key != value`
+ *  - `key`            (truthy check)
+ *  - `!key`           (falsy check)
+ *
+ * Values are compared as strings. Numeric values are coerced.
+ */
+export declare function evaluateCondition(condition: string, context: RoutingContext): boolean;
+export declare class EffectRouter {
+    private rules;
+    /**
+     * Add a routing rule. Rules are kept sorted by descending priority.
+     */
+    addRule(rule: RoutingRule): void;
+    /**
+     * Remove a routing rule by id. Returns true if it existed.
+     */
+    removeRule(id: string): boolean;
+    /**
+     * List all registered rules (ordered by descending priority).
+     */
+    listRules(): readonly RoutingRule[];
+    /**
+     * Route an effect descriptor (e.g. "shell:lint") to the best matching
+     * rule. Uses first-match-wins semantics (highest priority first).
+     *
+     * @param effectDescriptor - A string like "kind:label" or just "kind".
+     * @param context - Optional context for condition evaluation.
+     * @returns The matching routing result, or undefined if no rule matches.
+     */
+    route(effectDescriptor: string, context?: RoutingContext): RoutingResult | undefined;
+}
+//# sourceMappingURL=effectRouting.d.ts.map

package/dist/harness/effectRouting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectRouting.d.ts","sourceRoot":"","sources":["../../src/harness/effectRouting.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,8FAA8F;IAC9F,OAAO,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAmCvE;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CA2BrF;AAMD,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAqB;IAElC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAKhC;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAM/B;;OAEG;IACH,SAAS,IAAI,SAAS,WAAW,EAAE;IAInC;;;;;;;OAOG;IACH,KAAK,CAAC,gBAAgB,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,aAAa,GAAG,SAAS;CAkBrF"}

package/dist/harness/effectRouting.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Effect routing — pattern-matched routing of effects to harness/model
+ * targets with priority-based cascading rules (GAP-AGENT-003).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectRouter = void 0;
+exports.evaluateCondition = evaluateCondition;
+// ---------------------------------------------------------------------------
+// Glob-like pattern matching
+// ---------------------------------------------------------------------------
+/**
+ * Convert a simple glob pattern to a RegExp.
+ * Supports `*` (match any chars except `:`) and `**` (match anything including `:`).
+ */
+function globToRegex(pattern) {
+    let re = '';
+    let i = 0;
+    while (i < pattern.length) {
+        if (pattern[i] === '*' && pattern[i + 1] === '*') {
+            re += '.*';
+            i += 2;
+        }
+        else if (pattern[i] === '*') {
+            re += '[^:]*';
+            i++;
+        }
+        else if (pattern[i] === '?') {
+            re += '[^:]';
+            i++;
+        }
+        else {
+            re += pattern[i].replace(/[.+^${}()|[\]\\]/g, '\\$&');
+            i++;
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+// ---------------------------------------------------------------------------
+// Condition evaluator
+// ---------------------------------------------------------------------------
+/**
+ * Evaluate a simple condition expression against a context.
+ *
+ * Supported forms:
+ *  - `key == value`
+ *  - `key != value`
+ *  - `key`            (truthy check)
+ *  - `!key`           (falsy check)
+ *
+ * Values are compared as strings. Numeric values are coerced.
+ */
+function evaluateCondition(condition, context) {
+    const trimmed = condition.trim();
+    // key != value
+    const neq = trimmed.match(/^(\w+)\s*!=\s*(.+)$/);
+    if (neq) {
+        const key = neq[1];
+        const expected = neq[2].trim();
+        return String(context[key] ?? '') !== expected;
+    }
+    // key == value
+    const eq = trimmed.match(/^(\w+)\s*==\s*(.+)$/);
+    if (eq) {
+        const key = eq[1];
+        const expected = eq[2].trim();
+        return String(context[key] ?? '') === expected;
+    }
+    // !key (falsy)
+    if (trimmed.startsWith('!')) {
+        const key = trimmed.slice(1).trim();
+        return !context[key];
+    }
+    // key (truthy)
+    return !!context[trimmed];
+}
+// ---------------------------------------------------------------------------
+// EffectRouter
+// ---------------------------------------------------------------------------
+class EffectRouter {
+    rules = [];
+    /**
+     * Add a routing rule. Rules are kept sorted by descending priority.
+     */
+    addRule(rule) {
+        this.rules.push(rule);
+        this.rules.sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Remove a routing rule by id. Returns true if it existed.
+     */
+    removeRule(id) {
+        const before = this.rules.length;
+        this.rules = this.rules.filter((r) => r.id !== id);
+        return this.rules.length < before;
+    }
+    /**
+     * List all registered rules (ordered by descending priority).
+     */
+    listRules() {
+        return this.rules;
+    }
+    /**
+     * Route an effect descriptor (e.g. "shell:lint") to the best matching
+     * rule. Uses first-match-wins semantics (highest priority first).
+     *
+     * @param effectDescriptor - A string like "kind:label" or just "kind".
+     * @param context - Optional context for condition evaluation.
+     * @returns The matching routing result, or undefined if no rule matches.
+     */
+    route(effectDescriptor, context) {
+        for (const rule of this.rules) {
+            const regex = globToRegex(rule.pattern);
+            if (!regex.test(effectDescriptor))
+                continue;
+            // Check condition if present
+            if (rule.condition && context) {
+                if (!evaluateCondition(rule.condition, context))
+                    continue;
+            }
+            else if (rule.condition && !context) {
+                // Condition present but no context — skip this rule
+                continue;
+            }
+            return { rule, target: rule.target };
+        }
+        return undefined;
+    }
+}
+exports.EffectRouter = EffectRouter;

package/dist/harness/extensionToolBridge.d.ts

@@ -0,0 +1,13 @@
+import type { ExtensionRegistry } from '@a5c-ai/genty-core/extensions';
+export interface BridgedToolDefinition {
+    name: string;
+    description: string;
+    execute: (params: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+    }>;
+}
+export declare function bridgeExtensionTools(registry: ExtensionRegistry): BridgedToolDefinition[];
+//# sourceMappingURL=extensionToolBridge.d.ts.map

package/dist/harness/extensionToolBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensionToolBridge.d.ts","sourceRoot":"","sources":["../../src/harness/extensionToolBridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;QAAE,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC,CAAC;CAC3G;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,qBAAqB,EAAE,CAkBzF"}

package/dist/harness/extensionToolBridge.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bridgeExtensionTools = bridgeExtensionTools;
+function bridgeExtensionTools(registry) {
+    return registry.getAllTools().map((extTool) => ({
+        name: extTool.name,
+        description: extTool.description,
+        execute: async (params) => {
+            try {
+                const result = await extTool.handler(params);
+                return {
+                    content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }],
+                };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: 'text', text: `Extension tool error: ${message}` }],
+                };
+            }
+        },
+    }));
+}

package/dist/harness/fallbackChains.d.ts

@@ -0,0 +1,42 @@
+/**
+ * GAP-HADAPT-004: Harness Fallback Chains.
+ *
+ * Defines ordered fallback sequences for harness resolution.
+ * When a primary harness fails or is unavailable, the chain
+ * determines the next harness to try.
+ */
+export interface FallbackChain {
+    /** Ordered list of harness names (primary first). */
+    harnesses: string[];
+    /** Maximum number of retries (fallback attempts). */
+    maxRetries: number;
+}
+export interface FallbackChainOptions {
+    /** Maximum retries. Clamped to chain.length - 1. */
+    maxRetries?: number;
+}
+export interface FallbackResolution {
+    /** The harness to use, or null if all exhausted. */
+    harness: string | null;
+    /** 1-based attempt number. */
+    attempt: number;
+    /** Whether this is a fallback (not the primary). */
+    isFallback: boolean;
+    /** Whether all harnesses in the chain have been exhausted. */
+    exhausted: boolean;
+}
+/**
+ * Create a fallback chain from an ordered list of harness names.
+ *
+ * Duplicates are removed (first occurrence wins).
+ * maxRetries defaults to chain.length - 1 (try every harness once).
+ */
+export declare function createFallbackChain(harnesses: string[], options?: FallbackChainOptions): FallbackChain;
+/**
+ * Resolve which harness to use given a chain and previously failed harnesses.
+ *
+ * Returns the first harness in the chain that hasn't failed yet,
+ * respecting the maxRetries limit.
+ */
+export declare function resolveFallbackHarness(chain: FallbackChain, failedHarnesses: string[]): FallbackResolution;
+//# sourceMappingURL=fallbackChains.d.ts.map

package/dist/harness/fallbackChains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallbackChains.d.ts","sourceRoot":"","sources":["../../src/harness/fallbackChains.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,oDAAoD;IACpD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,UAAU,EAAE,OAAO,CAAC;IACpB,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAC;CACpB;AAMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAYf;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,aAAa,EACpB,eAAe,EAAE,MAAM,EAAE,GACxB,kBAAkB,CAiCpB"}

package/dist/harness/fallbackChains.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * GAP-HADAPT-004: Harness Fallback Chains.
+ *
+ * Defines ordered fallback sequences for harness resolution.
+ * When a primary harness fails or is unavailable, the chain
+ * determines the next harness to try.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFallbackChain = createFallbackChain;
+exports.resolveFallbackHarness = resolveFallbackHarness;
+// ---------------------------------------------------------------------------
+// Core
+// ---------------------------------------------------------------------------
+/**
+ * Create a fallback chain from an ordered list of harness names.
+ *
+ * Duplicates are removed (first occurrence wins).
+ * maxRetries defaults to chain.length - 1 (try every harness once).
+ */
+function createFallbackChain(harnesses, options) {
+    // Deduplicate preserving order
+    const unique = [...new Set(harnesses)];
+    const maxPossible = Math.max(0, unique.length - 1);
+    const maxRetries = options?.maxRetries !== undefined
+        ? Math.min(options.maxRetries, maxPossible)
+        : maxPossible;
+    return {
+        harnesses: unique,
+        maxRetries,
+    };
+}
+/**
+ * Resolve which harness to use given a chain and previously failed harnesses.
+ *
+ * Returns the first harness in the chain that hasn't failed yet,
+ * respecting the maxRetries limit.
+ */
+function resolveFallbackHarness(chain, failedHarnesses) {
+    const failedSet = new Set(failedHarnesses);
+    const attempt = failedHarnesses.length + 1;
+    // Check retry limit: attempts beyond maxRetries + 1 are exhausted
+    if (failedHarnesses.length > chain.maxRetries) {
+        return {
+            harness: null,
+            attempt,
+            isFallback: attempt > 1,
+            exhausted: true,
+        };
+    }
+    // Find the first non-failed harness in chain order
+    for (const harness of chain.harnesses) {
+        if (!failedSet.has(harness)) {
+            return {
+                harness,
+                attempt,
+                isFallback: harness !== chain.harnesses[0],
+                exhausted: false,
+            };
+        }
+    }
+    // All harnesses in the chain have failed
+    return {
+        harness: null,
+        attempt,
+        isFallback: true,
+        exhausted: true,
+    };
+}