@framers/agentos 0.1.229 → 0.1.230

package/dist/emergent/ForgeRejectionClassifier.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Classify forge-rejection `errorReason` strings into a
+ * small set of actionable categories.
+ * @module @framers/agentos/emergent/ForgeRejectionClassifier
+ *
+ * Without categorization, the only way to answer "why are forges failing"
+ * is to grep logs. With classification, an aggregator can emit a live
+ * histogram of failure modes (schema-extra-field vs shape-check vs judge
+ * correctness vs parse error) so operators see the failure-mode
+ * distribution without log access.
+ *
+ * Categories are deliberately narrow. They split out the patterns that
+ * appear in real production rejection text; anything unrecognized falls
+ * into `other`. A growing `other` bucket is the signal to read raw
+ * reasons and extend the pattern set.
+ */
+/**
+ * Rejection-reason category produced by {@link classifyForgeRejection}.
+ */
+export type ForgeRejectionCategory = 
+/**
+ * Implementation returned output fields not declared in outputSchema
+ * (violates `additionalProperties: false`). The most common forge
+ * failure mode under a strict schema contract.
+ */
+'schema_extra_field'
+/**
+ * Pre-judge shape validator caught a malformed request (empty schema
+ * properties, empty testCases, empty-input testCases).
+ */
+ | 'shape_check'
+/**
+ * Judge LLM returned malformed JSON the engine could not parse.
+ */
+ | 'parse_error'
+/**
+ * Judge flagged logic / correctness / safety concerns in the code
+ * itself (division bugs, threshold inversions, unbounded outputs,
+ * non-deterministic behavior).
+ */
+ | 'judge_correctness'
+/**
+ * Everything else. A non-zero `other` bucket is a signal to inspect
+ * the raw reasons and consider adding a new category.
+ */
+ | 'other';
+/**
+ * Classify a rejection reason string into a {@link ForgeRejectionCategory}.
+ *
+ * Case-insensitive substring match against pattern lists, evaluated in
+ * order: schema_extra_field first (most common and most actionable),
+ * then shape_check (local pre-validator), then parse_error, then
+ * judge_correctness, then `other`.
+ *
+ * Order matters: "violates the declared output schema by returning an
+ * additional field due to a logic error" matches BOTH schema_extra_field
+ * and judge_correctness; the former wins because it is the more specific
+ * and more actionable signal.
+ *
+ * @param errorReason Raw rejection reason text, typically the judge's
+ *   verdict reasoning or the local shape-validator's joined error list.
+ *   May be `undefined` when no reason was captured.
+ * @returns One of the five category labels. Empty / `undefined` input
+ *   returns `'other'`.
+ */
+export declare function classifyForgeRejection(errorReason: string | undefined): ForgeRejectionCategory;
+//# sourceMappingURL=ForgeRejectionClassifier.d.ts.map

package/dist/emergent/ForgeRejectionClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgeRejectionClassifier.d.ts","sourceRoot":"","sources":["../../src/emergent/ForgeRejectionClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;GAEG;AACH,MAAM,MAAM,sBAAsB;AAChC;;;;GAIG;AACD,oBAAoB;AACtB;;;GAGG;GACD,aAAa;AACf;;GAEG;GACD,aAAa;AACf;;;;GAIG;GACD,mBAAmB;AACrB;;;GAGG;GACD,OAAO,CAAC;AAuEZ;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,sBAAsB,CAoB9F"}

package/dist/emergent/ForgeRejectionClassifier.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Classify forge-rejection `errorReason` strings into a
+ * small set of actionable categories.
+ * @module @framers/agentos/emergent/ForgeRejectionClassifier
+ *
+ * Without categorization, the only way to answer "why are forges failing"
+ * is to grep logs. With classification, an aggregator can emit a live
+ * histogram of failure modes (schema-extra-field vs shape-check vs judge
+ * correctness vs parse error) so operators see the failure-mode
+ * distribution without log access.
+ *
+ * Categories are deliberately narrow. They split out the patterns that
+ * appear in real production rejection text; anything unrecognized falls
+ * into `other`. A growing `other` bucket is the signal to read raw
+ * reasons and extend the pattern set.
+ */
+const SCHEMA_EXTRA_FIELD_PATTERNS = [
+    'additional properties',
+    'additional property',
+    'additionalproperties',
+    'extra field',
+    'extra fields',
+    'extra property',
+    'extra properties',
+    'undeclared extra field',
+    'undeclared field',
+    'emits an additional',
+    'emits extra',
+    'returning an additional',
+    'returning extra',
+    'returns an additional',
+    'returns extra',
+    'returns additional',
+    'returning an undeclared',
+];
+/**
+ * Regex-based patterns for "extra <modifier> field" phrasings that
+ * substring matching misses. Example: "extra recommendations field"
+ * is clearly a schema-extra-field rejection but the contiguous string
+ * "extra field" is absent. These regexes catch the general form.
+ */
+const SCHEMA_EXTRA_FIELD_REGEXES = [
+    /\bextra\s+\w+\s+field\b/,
+    /\badditional\s+\w+\s+field\b/,
+    /\bextra\s+\w+\s+property\b/,
+    /\badditional\s+\w+\s+property\b/,
+];
+const SHAPE_CHECK_PATTERNS = [
+    'shape check failed',
+    'inputschema has no declared properties',
+    'outputschema has no declared properties',
+    'testcases use empty input',
+    'testcase use empty input',
+    'need at least 2 testcases',
+    'every test needs real field values',
+];
+const PARSE_ERROR_PATTERNS = [
+    'failed to parse llm response',
+    'could not parse judge response',
+    'judge response was not valid json',
+];
+const JUDGE_CORRECTNESS_PATTERNS = [
+    'logic error',
+    'threshold ordering',
+    'clamped',
+    'unclamped',
+    'inconsistent risk grading',
+    'division by zero',
+    'unbounded output',
+    'unbounded',
+    'returns nan',
+    'returns infinity',
+    'infinite loop',
+    'not deterministic',
+    'nondeterministic',
+    'correctness is questionable',
+    'correctness concern',
+    'fails safety',
+    'safety concern',
+];
+/**
+ * Classify a rejection reason string into a {@link ForgeRejectionCategory}.
+ *
+ * Case-insensitive substring match against pattern lists, evaluated in
+ * order: schema_extra_field first (most common and most actionable),
+ * then shape_check (local pre-validator), then parse_error, then
+ * judge_correctness, then `other`.
+ *
+ * Order matters: "violates the declared output schema by returning an
+ * additional field due to a logic error" matches BOTH schema_extra_field
+ * and judge_correctness; the former wins because it is the more specific
+ * and more actionable signal.
+ *
+ * @param errorReason Raw rejection reason text, typically the judge's
+ *   verdict reasoning or the local shape-validator's joined error list.
+ *   May be `undefined` when no reason was captured.
+ * @returns One of the five category labels. Empty / `undefined` input
+ *   returns `'other'`.
+ */
+export function classifyForgeRejection(errorReason) {
+    if (!errorReason)
+        return 'other';
+    const lower = errorReason.toLowerCase();
+    for (const p of SCHEMA_EXTRA_FIELD_PATTERNS) {
+        if (lower.includes(p))
+            return 'schema_extra_field';
+    }
+    for (const rx of SCHEMA_EXTRA_FIELD_REGEXES) {
+        if (rx.test(lower))
+            return 'schema_extra_field';
+    }
+    for (const p of SHAPE_CHECK_PATTERNS) {
+        if (lower.includes(p))
+            return 'shape_check';
+    }
+    for (const p of PARSE_ERROR_PATTERNS) {
+        if (lower.includes(p))
+            return 'parse_error';
+    }
+    for (const p of JUDGE_CORRECTNESS_PATTERNS) {
+        if (lower.includes(p))
+            return 'judge_correctness';
+    }
+    return 'other';
+}
+//# sourceMappingURL=ForgeRejectionClassifier.js.map

package/dist/emergent/ForgeRejectionClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgeRejectionClassifier.js","sourceRoot":"","sources":["../../src/emergent/ForgeRejectionClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAiCH,MAAM,2BAA2B,GAAG;IAClC,uBAAuB;IACvB,qBAAqB;IACrB,sBAAsB;IACtB,aAAa;IACb,cAAc;IACd,gBAAgB;IAChB,kBAAkB;IAClB,wBAAwB;IACxB,kBAAkB;IAClB,qBAAqB;IACrB,aAAa;IACb,yBAAyB;IACzB,iBAAiB;IACjB,uBAAuB;IACvB,eAAe;IACf,oBAAoB;IACpB,yBAAyB;CAC1B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,0BAA0B,GAAa;IAC3C,yBAAyB;IACzB,8BAA8B;IAC9B,4BAA4B;IAC5B,iCAAiC;CAClC,CAAC;AAEF,MAAM,oBAAoB,GAAG;IAC3B,oBAAoB;IACpB,wCAAwC;IACxC,yCAAyC;IACzC,2BAA2B;IAC3B,0BAA0B;IAC1B,2BAA2B;IAC3B,oCAAoC;CACrC,CAAC;AAEF,MAAM,oBAAoB,GAAG;IAC3B,8BAA8B;IAC9B,gCAAgC;IAChC,mCAAmC;CACpC,CAAC;AAEF,MAAM,0BAA0B,GAAG;IACjC,aAAa;IACb,oBAAoB;IACpB,SAAS;IACT,WAAW;IACX,2BAA2B;IAC3B,kBAAkB;IAClB,kBAAkB;IAClB,WAAW;IACX,aAAa;IACb,kBAAkB;IAClB,eAAe;IACf,mBAAmB;IACnB,kBAAkB;IAClB,6BAA6B;IAC7B,qBAAqB;IACrB,cAAc;IACd,gBAAgB;CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,sBAAsB,CAAC,WAA+B;IACpE,IAAI,CAAC,WAAW;QAAE,OAAO,OAAO,CAAC;IACjC,MAAM,KAAK,GAAG,WAAW,CAAC,WAAW,EAAE,CAAC;IAExC,KAAK,MAAM,CAAC,IAAI,2BAA2B,EAAE,CAAC;QAC5C,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,oBAAoB,CAAC;IACrD,CAAC;IACD,KAAK,MAAM,EAAE,IAAI,0BAA0B,EAAE,CAAC;QAC5C,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,oBAAoB,CAAC;IAClD,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,oBAAoB,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,aAAa,CAAC;IAC9C,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,oBAAoB,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,aAAa,CAAC;IAC9C,CAAC;IACD,KAAK,MAAM,CAAC,IAAI,0BAA0B,EAAE,CAAC;QAC3C,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;YAAE,OAAO,mBAAmB,CAAC;IACpD,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/emergent/ForgeSchemaInference.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Synthesize missing forge input/output schema properties
+ * from testCase values.
+ * @module @framers/agentos/emergent/ForgeSchemaInference
+ *
+ * Problem: LLMs routinely emit concrete testCases with real field values
+ * but forget to declare `inputSchema.properties` / `outputSchema.properties`.
+ * The shape validator then rejects every such forge even though the
+ * intent is clearly legitimate.
+ *
+ * Solution: when a schema lacks declared properties but the testCases
+ * carry field values, synthesize properties from the testCase data so
+ * the shape check passes. This is NOT a relaxation of schema discipline
+ * — the tool code still has to handle whatever inputs come in. It is a
+ * correction of a common LLM oversight (examples without formalization).
+ *
+ * Pure function, mutates the request in place. No dependencies.
+ */
+/** Request fragment carrying the three fields we may mutate. */
+export interface ForgeSchemaInferenceRequest {
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    testCases?: unknown;
+}
+/**
+ * Populate missing inputSchema / outputSchema properties from testCase
+ * data. Mutates `req` in place. Fields are scanned as a union across
+ * every testCase so a single incomplete case does not narrow the
+ * inferred schema.
+ *
+ * A schema that already has declared properties is left alone. Only
+ * the missing-properties case is upgraded. `additionalProperties: false`
+ * is added to the synthesized schema so the strict-schema discipline is
+ * preserved for the generated shape.
+ *
+ * @param req Forge request fragment. Mutated in place.
+ */
+export declare function inferSchemaFromTestCases(req: ForgeSchemaInferenceRequest): void;
+//# sourceMappingURL=ForgeSchemaInference.d.ts.map

package/dist/emergent/ForgeSchemaInference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgeSchemaInference.d.ts","sourceRoot":"","sources":["../../src/emergent/ForgeSchemaInference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,gEAAgE;AAChE,MAAM,WAAW,2BAA2B;IAC1C,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAiBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,2BAA2B,GAAG,IAAI,CAiD/E"}

package/dist/emergent/ForgeSchemaInference.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Synthesize missing forge input/output schema properties
+ * from testCase values.
+ * @module @framers/agentos/emergent/ForgeSchemaInference
+ *
+ * Problem: LLMs routinely emit concrete testCases with real field values
+ * but forget to declare `inputSchema.properties` / `outputSchema.properties`.
+ * The shape validator then rejects every such forge even though the
+ * intent is clearly legitimate.
+ *
+ * Solution: when a schema lacks declared properties but the testCases
+ * carry field values, synthesize properties from the testCase data so
+ * the shape check passes. This is NOT a relaxation of schema discipline
+ * — the tool code still has to handle whatever inputs come in. It is a
+ * correction of a common LLM oversight (examples without formalization).
+ *
+ * Pure function, mutates the request in place. No dependencies.
+ */
+/**
+ * Derive a JSON-Schema primitive type from a concrete testCase value.
+ * Handles the types the sandbox forge returns: number, string, boolean,
+ * object, array. Falls back to `'string'` for anything else so the
+ * schema stays well-formed.
+ */
+function inferTypeFromValue(v) {
+    if (typeof v === 'number')
+        return 'number';
+    if (typeof v === 'boolean')
+        return 'boolean';
+    if (typeof v === 'string')
+        return 'string';
+    if (Array.isArray(v))
+        return 'array';
+    if (v !== null && typeof v === 'object')
+        return 'object';
+    return 'string';
+}
+/**
+ * Populate missing inputSchema / outputSchema properties from testCase
+ * data. Mutates `req` in place. Fields are scanned as a union across
+ * every testCase so a single incomplete case does not narrow the
+ * inferred schema.
+ *
+ * A schema that already has declared properties is left alone. Only
+ * the missing-properties case is upgraded. `additionalProperties: false`
+ * is added to the synthesized schema so the strict-schema discipline is
+ * preserved for the generated shape.
+ *
+ * @param req Forge request fragment. Mutated in place.
+ */
+export function inferSchemaFromTestCases(req) {
+    const tcArr = Array.isArray(req.testCases)
+        ? req.testCases
+        : [];
+    if (tcArr.length === 0)
+        return;
+    const inferProperties = (key) => {
+        const props = {};
+        for (const tc of tcArr) {
+            const data = tc?.[key];
+            if (!data || typeof data !== 'object' || Array.isArray(data))
+                continue;
+            for (const [field, value] of Object.entries(data)) {
+                if (props[field])
+                    continue;
+                props[field] = { type: inferTypeFromValue(value) };
+            }
+        }
+        return props;
+    };
+    const maybeUpgrade = (schemaKey, testCaseKey) => {
+        const schema = req[schemaKey];
+        const current = (schema && typeof schema === 'object' ? schema : {});
+        const hasProps = current.properties &&
+            typeof current.properties === 'object' &&
+            Object.keys(current.properties).length > 0;
+        if (hasProps)
+            return;
+        const inferred = inferProperties(testCaseKey);
+        if (Object.keys(inferred).length === 0)
+            return;
+        req[schemaKey] = {
+            type: 'object',
+            properties: inferred,
+            required: Object.keys(inferred),
+            additionalProperties: false,
+        };
+    };
+    maybeUpgrade('inputSchema', 'input');
+    maybeUpgrade('outputSchema', 'expectedOutput');
+}
+//# sourceMappingURL=ForgeSchemaInference.js.map

package/dist/emergent/ForgeSchemaInference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgeSchemaInference.js","sourceRoot":"","sources":["../../src/emergent/ForgeSchemaInference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AASH;;;;;GAKG;AACH,SAAS,kBAAkB,CAAC,CAAU;IACpC,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC3C,IAAI,OAAO,CAAC,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC7C,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC3C,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO,OAAO,CAAC;IACrC,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,QAAQ,CAAC;IACzD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAAgC;IACvE,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;QACxC,CAAC,CAAE,GAAG,CAAC,SAAkE;QACzE,CAAC,CAAC,EAAE,CAAC;IACP,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAE/B,MAAM,eAAe,GAAG,CAAC,GAA+B,EAAE,EAAE;QAC1D,MAAM,KAAK,GAAqC,EAAE,CAAC;QACnD,KAAK,MAAM,EAAE,IAAI,KAAK,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;YACvB,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;gBAAE,SAAS;YACvE,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAA+B,CAAC,EAAE,CAAC;gBAC7E,IAAI,KAAK,CAAC,KAAK,CAAC;oBAAE,SAAS;gBAC3B,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;YACrD,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,YAAY,GAAG,CACnB,SAAyC,EACzC,WAAuC,EACvC,EAAE;QACF,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;QAC9B,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAKlE,CAAC;QACF,MAAM,QAAQ,GACZ,OAAO,CAAC,UAAU;YAClB,OAAO,OAAO,CAAC,UAAU,KAAK,QAAQ;YACtC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;QAC7C,IAAI,QAAQ;YAAE,OAAO;QAErB,MAAM,QAAQ,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;QAC9C,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAE/C,GAAG,CAAC,SAAS,CAAC,GAAG;YACf,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,QAAQ;YACpB,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;YAC/B,oBAAoB,EAAE,KAAK;SAC5B,CAAC;IACJ,CAAC,CAAC;IAEF,YAAY,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IACrC,YAAY,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;AACjD,CAAC"}

package/dist/emergent/ForgeShapeValidator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Pre-judge shape validator for forge requests.
+ * @module @framers/agentos/emergent/ForgeShapeValidator
+ *
+ * Catches the failure modes that dominate cheap-tier forge rejections
+ * (empty schema properties, too-few testCases, empty-input testCases)
+ * BEFORE the judge LLM sees the request. Every shape-check rejection
+ * saves one judge invocation plus the sandbox round-trip that would
+ * have followed it.
+ *
+ * Pure function, no dependencies.
+ */
+/**
+ * Minimal forge request shape the validator needs. Accepts `unknown`
+ * for the schema fields so callers can pass raw LLM output without
+ * pre-shaping.
+ */
+export interface ForgeShapeRequest {
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    testCases?: unknown;
+}
+/**
+ * Validate a forge request's shape against the rules that dominate
+ * cheap-tier failures. Every violation is reported at once (no
+ * short-circuit) so the caller can build one comprehensive error
+ * message to show the LLM.
+ *
+ * Rules enforced:
+ * - `inputSchema.properties` must declare at least one field.
+ * - `outputSchema.properties` must declare at least one field.
+ * - `testCases` must have at least 2 entries.
+ * - Every testCase must have a non-empty `input` object.
+ *
+ * @param req Request fragment. Only the three fields are inspected;
+ *   other fields on the forge request are ignored.
+ * @returns Array of human-readable error strings. Empty means the
+ *   request's shape is well-formed enough to forward to the judge.
+ */
+export declare function validateForgeShape(req: ForgeShapeRequest): string[];
+//# sourceMappingURL=ForgeShapeValidator.d.ts.map

package/dist/emergent/ForgeShapeValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgeShapeValidator.d.ts","sourceRoot":"","sources":["../../src/emergent/ForgeShapeValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,EAAE,CA8BnE"}

package/dist/emergent/ForgeShapeValidator.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Pre-judge shape validator for forge requests.
+ * @module @framers/agentos/emergent/ForgeShapeValidator
+ *
+ * Catches the failure modes that dominate cheap-tier forge rejections
+ * (empty schema properties, too-few testCases, empty-input testCases)
+ * BEFORE the judge LLM sees the request. Every shape-check rejection
+ * saves one judge invocation plus the sandbox round-trip that would
+ * have followed it.
+ *
+ * Pure function, no dependencies.
+ */
+/**
+ * Validate a forge request's shape against the rules that dominate
+ * cheap-tier failures. Every violation is reported at once (no
+ * short-circuit) so the caller can build one comprehensive error
+ * message to show the LLM.
+ *
+ * Rules enforced:
+ * - `inputSchema.properties` must declare at least one field.
+ * - `outputSchema.properties` must declare at least one field.
+ * - `testCases` must have at least 2 entries.
+ * - Every testCase must have a non-empty `input` object.
+ *
+ * @param req Request fragment. Only the three fields are inspected;
+ *   other fields on the forge request are ignored.
+ * @returns Array of human-readable error strings. Empty means the
+ *   request's shape is well-formed enough to forward to the judge.
+ */
+export function validateForgeShape(req) {
+    const errors = [];
+    const inputSchema = req.inputSchema;
+    const outputSchema = req.outputSchema;
+    const inputProps = inputSchema && typeof inputSchema.properties === 'object' ? inputSchema.properties : null;
+    const outputProps = outputSchema && typeof outputSchema.properties === 'object' ? outputSchema.properties : null;
+    if (!inputProps || Object.keys(inputProps).length === 0) {
+        errors.push('inputSchema has no declared properties; add at least two typed fields');
+    }
+    if (!outputProps || Object.keys(outputProps).length === 0) {
+        errors.push('outputSchema has no declared properties; add at least one typed output field');
+    }
+    const tcArr = Array.isArray(req.testCases)
+        ? req.testCases
+        : [];
+    if (tcArr.length < 2) {
+        errors.push(`need at least 2 testCases, got ${tcArr.length}`);
+    }
+    const emptyInputs = tcArr.filter(tc => {
+        const inp = tc?.input;
+        return !inp || typeof inp !== 'object' || Object.keys(inp).length === 0;
+    }).length;
+    if (emptyInputs > 0) {
+        errors.push(`${emptyInputs} testCase${emptyInputs === 1 ? '' : 's'} use empty input; every test needs real field values`);
+    }
+    return errors;
+}
+//# sourceMappingURL=ForgeShapeValidator.js.map

package/dist/emergent/ForgeShapeValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgeShapeValidator.js","sourceRoot":"","sources":["../../src/emergent/ForgeShapeValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAaH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAsB;IACvD,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,WAAW,GAAG,GAAG,CAAC,WAA8D,CAAC;IACvF,MAAM,YAAY,GAAG,GAAG,CAAC,YAA+D,CAAC;IACzF,MAAM,UAAU,GACd,WAAW,IAAI,OAAO,WAAW,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5F,MAAM,WAAW,GACf,YAAY,IAAI,OAAO,YAAY,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC;IAC/F,IAAI,CAAC,UAAU,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxD,MAAM,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;IACvF,CAAC;IACD,IAAI,CAAC,WAAW,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1D,MAAM,CAAC,IAAI,CAAC,8EAA8E,CAAC,CAAC;IAC9F,CAAC;IACD,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;QACxC,CAAC,CAAE,GAAG,CAAC,SAAkE;QACzE,CAAC,CAAC,EAAE,CAAC;IACP,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,CAAC,IAAI,CAAC,kCAAkC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAChE,CAAC;IACD,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;QACpC,MAAM,GAAG,GAAG,EAAE,EAAE,KAAK,CAAC;QACtB,OAAO,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,GAA8B,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC;IACrG,CAAC,CAAC,CAAC,MAAM,CAAC;IACV,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;QACpB,MAAM,CAAC,IAAI,CACT,GAAG,WAAW,YAAY,WAAW,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,sDAAsD,CAC7G,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/emergent/ForgeStatsAggregator.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @fileoverview Standalone per-run aggregator for forge reliability
+ * telemetry. Composes with any cost/usage tracker the consumer already
+ * has.
+ * @module @framers/agentos/emergent/ForgeStatsAggregator
+ *
+ * Pinned shape: the {@link ForgeStats} snapshot must stay stable. It
+ * ships through consumer telemetry endpoints that downstream dashboards
+ * parse; renaming fields is a breaking change. Fold in new dimensions
+ * by adding fields, not renaming existing ones.
+ */
+import { type ForgeRejectionCategory } from './ForgeRejectionClassifier.js';
+/** Per-run forge reliability rollup snapshot. */
+export interface ForgeStats {
+    /** Total forge attempts (approved + rejected combined). */
+    attempts: number;
+    /** Attempts the judge approved. */
+    approved: number;
+    /** Attempts the judge or shape validator rejected. */
+    rejected: number;
+    /** Sum of confidence across approved attempts. Divide by `approved` for avg. */
+    approvedConfidenceSum: number;
+    /**
+     * Count of unique tool names seen this run (union of approved + rejected).
+     * A tool rejected then re-forged under the same name counts once.
+     */
+    uniqueNames: number;
+    /** Count of unique tool names that landed approved at least once this run. */
+    uniqueApproved: number;
+    /**
+     * Count of unique tool names that were ONLY rejected (never approved)
+     * this run. The retry loop did not recover these. Actionable signal
+     * for "real quality failures" vs retry churn.
+     */
+    uniqueTerminalRejections: number;
+    /**
+     * Histogram of rejection reasons, classified via
+     * {@link classifyForgeRejection}. Keys match {@link ForgeRejectionCategory}.
+     */
+    rejectionReasons: Record<ForgeRejectionCategory, number>;
+}
+/**
+ * Create a fresh, zeroed {@link ForgeStats} snapshot. Exposed for consumers
+ * that want to seed their own state or compare against a baseline.
+ */
+export declare function emptyForgeStats(): ForgeStats;
+/**
+ * Aggregator for forge outcomes across a single run. No dependency on
+ * the cost tracker or any consumer-specific types — consumers compose
+ * it into whatever telemetry layer they already have.
+ *
+ * Typical wiring: the consumer's forge capture callback calls
+ * {@link recordAttempt} with the outcome fields, then embeds
+ * {@link snapshot} under a `forgeStats` key in whatever payload the
+ * consumer ships to clients.
+ */
+export declare class ForgeStatsAggregator {
+    private stats;
+    private readonly approvedNames;
+    private readonly rejectedNames;
+    /**
+     * Record one forge attempt's outcome.
+     *
+     * @param approved `true` when the judge approved; `false` for shape-check
+     *   or judge rejections.
+     * @param confidence Judge's confidence score for approved tools. Summed
+     *   into `approvedConfidenceSum` (skipped for rejections so rejection
+     *   confidence does not dilute the average).
+     * @param toolName Optional tool name. When provided, tracks unique-tool
+     *   metrics (eventually-approved vs terminally-rejected) rather than
+     *   raw attempt counts.
+     * @param errorReason Optional rejection-reason string. On a rejected
+     *   attempt, passed through {@link classifyForgeRejection} and binned
+     *   into `rejectionReasons`.
+     */
+    recordAttempt(approved: boolean, confidence: number, toolName?: string, errorReason?: string): void;
+    /**
+     * Build a plain-object snapshot of current stats. Safe to JSON-serialize
+     * and ship to clients. Returns a shallow copy so callers can mutate
+     * without affecting the aggregator's internal state.
+     */
+    snapshot(): ForgeStats;
+    /**
+     * Clear all accumulated state. Useful when the aggregator is reused
+     * across multiple runs in one process.
+     */
+    reset(): void;
+    /**
+     * Recompute the three unique-tool counters from the name sets. Called
+     * after every attempt so `snapshot()` never has to do the math itself.
+     */
+    private refreshUniqueCounts;
+}
+//# sourceMappingURL=ForgeStatsAggregator.d.ts.map

package/dist/emergent/ForgeStatsAggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForgeStatsAggregator.d.ts","sourceRoot":"","sources":["../../src/emergent/ForgeStatsAggregator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,+BAA+B,CAAC;AAEvC,iDAAiD;AACjD,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,gFAAgF;IAChF,qBAAqB,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,wBAAwB,EAAE,MAAM,CAAC;IACjC;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC;CAC1D;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,UAAU,CAiB5C;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IAEnD;;;;;;;;;;;;;;OAcG;IACH,aAAa,CACX,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI;IAeP;;;;OAIG;IACH,QAAQ,IAAI,UAAU;IAOtB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAMb;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAY5B"}

package/dist/emergent/ForgeStatsAggregator.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Standalone per-run aggregator for forge reliability
+ * telemetry. Composes with any cost/usage tracker the consumer already
+ * has.
+ * @module @framers/agentos/emergent/ForgeStatsAggregator
+ *
+ * Pinned shape: the {@link ForgeStats} snapshot must stay stable. It
+ * ships through consumer telemetry endpoints that downstream dashboards
+ * parse; renaming fields is a breaking change. Fold in new dimensions
+ * by adding fields, not renaming existing ones.
+ */
+import { classifyForgeRejection, } from './ForgeRejectionClassifier.js';
+/**
+ * Create a fresh, zeroed {@link ForgeStats} snapshot. Exposed for consumers
+ * that want to seed their own state or compare against a baseline.
+ */
+export function emptyForgeStats() {
+    return {
+        attempts: 0,
+        approved: 0,
+        rejected: 0,
+        approvedConfidenceSum: 0,
+        uniqueNames: 0,
+        uniqueApproved: 0,
+        uniqueTerminalRejections: 0,
+        rejectionReasons: {
+            schema_extra_field: 0,
+            shape_check: 0,
+            parse_error: 0,
+            judge_correctness: 0,
+            other: 0,
+        },
+    };
+}
+/**
+ * Aggregator for forge outcomes across a single run. No dependency on
+ * the cost tracker or any consumer-specific types — consumers compose
+ * it into whatever telemetry layer they already have.
+ *
+ * Typical wiring: the consumer's forge capture callback calls
+ * {@link recordAttempt} with the outcome fields, then embeds
+ * {@link snapshot} under a `forgeStats` key in whatever payload the
+ * consumer ships to clients.
+ */
+export class ForgeStatsAggregator {
+    constructor() {
+        this.stats = emptyForgeStats();
+        this.approvedNames = new Set();
+        this.rejectedNames = new Set();
+    }
+    /**
+     * Record one forge attempt's outcome.
+     *
+     * @param approved `true` when the judge approved; `false` for shape-check
+     *   or judge rejections.
+     * @param confidence Judge's confidence score for approved tools. Summed
+     *   into `approvedConfidenceSum` (skipped for rejections so rejection
+     *   confidence does not dilute the average).
+     * @param toolName Optional tool name. When provided, tracks unique-tool
+     *   metrics (eventually-approved vs terminally-rejected) rather than
+     *   raw attempt counts.
+     * @param errorReason Optional rejection-reason string. On a rejected
+     *   attempt, passed through {@link classifyForgeRejection} and binned
+     *   into `rejectionReasons`.
+     */
+    recordAttempt(approved, confidence, toolName, errorReason) {
+        this.stats.attempts += 1;
+        if (approved) {
+            this.stats.approved += 1;
+            this.stats.approvedConfidenceSum += confidence;
+            if (toolName)
+                this.approvedNames.add(toolName);
+        }
+        else {
+            this.stats.rejected += 1;
+            if (toolName)
+                this.rejectedNames.add(toolName);
+            const category = classifyForgeRejection(errorReason);
+            this.stats.rejectionReasons[category] += 1;
+        }
+        this.refreshUniqueCounts();
+    }
+    /**
+     * Build a plain-object snapshot of current stats. Safe to JSON-serialize
+     * and ship to clients. Returns a shallow copy so callers can mutate
+     * without affecting the aggregator's internal state.
+     */
+    snapshot() {
+        return {
+            ...this.stats,
+            rejectionReasons: { ...this.stats.rejectionReasons },
+        };
+    }
+    /**
+     * Clear all accumulated state. Useful when the aggregator is reused
+     * across multiple runs in one process.
+     */
+    reset() {
+        this.stats = emptyForgeStats();
+        this.approvedNames.clear();
+        this.rejectedNames.clear();
+    }
+    /**
+     * Recompute the three unique-tool counters from the name sets. Called
+     * after every attempt so `snapshot()` never has to do the math itself.
+     */
+    refreshUniqueCounts() {
+        this.stats.uniqueApproved = this.approvedNames.size;
+        let terminal = 0;
+        for (const n of this.rejectedNames) {
+            if (!this.approvedNames.has(n))
+                terminal += 1;
+        }
+        this.stats.uniqueTerminalRejections = terminal;
+        const union = new Set();
+        for (const n of this.approvedNames)
+            union.add(n);
+        for (const n of this.rejectedNames)
+            union.add(n);
+        this.stats.uniqueNames = union.size;
+    }
+}
+//# sourceMappingURL=ForgeStatsAggregator.js.map

package/dist/emergent/ForgeStatsAggregator.js.map

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

package/dist/emergent/index.d.ts

@@ -33,4 +33,9 @@ export { SelfEvaluateTool } from './SelfEvaluateTool.js';
 export { PersonalityMutationStore } from './PersonalityMutationStore.js';
 export type { PersonalityMutation, RecordMutationInput, DecayResult } from './PersonalityMutationStore.js';
 export type { SelfImprovementToolDeps } from './EmergentCapabilityEngine.js';
+export { classifyForgeRejection, type ForgeRejectionCategory, } from './ForgeRejectionClassifier.js';
+export { validateForgeShape, type ForgeShapeRequest, } from './ForgeShapeValidator.js';
+export { inferSchemaFromTestCases, type ForgeSchemaInferenceRequest, } from './ForgeSchemaInference.js';
+export { wrapForgeTool, type CapturedForge, type ForgeLogEvent, type WrapForgeToolOptions, } from './wrapForgeTool.js';
+export { ForgeStatsAggregator, emptyForgeStats, type ForgeStats, } from './ForgeStatsAggregator.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/emergent/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/emergent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,KAAK,qBAAqB,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,YAAY,EACV,eAAe,IAAI,8BAA8B,EACjD,UAAU,GACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,oCAAoC,EACpC,wBAAwB,EACxB,4BAA4B,EAC5B,wBAAwB,EACxB,kCAAkC,GACnC,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,6BAA6B,EAC7B,0BAA0B,EAC1B,2BAA2B,EAC3B,+BAA+B,EAC/B,yCAAyC,GAC1C,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC3G,YAAY,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/emergent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,KAAK,qBAAqB,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,YAAY,EACV,eAAe,IAAI,8BAA8B,EACjD,UAAU,GACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,oCAAoC,EACpC,wBAAwB,EACxB,4BAA4B,EAC5B,wBAAwB,EACxB,kCAAkC,GACnC,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,6BAA6B,EAC7B,0BAA0B,EAC1B,2BAA2B,EAC3B,+BAA+B,EAC/B,yCAAyC,GAC1C,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,YAAY,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC3G,YAAY,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAM7E,OAAO,EACL,sBAAsB,EACtB,KAAK,sBAAsB,GAC5B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,KAAK,iBAAiB,GACvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,wBAAwB,EACxB,KAAK,2BAA2B,GACjC,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,aAAa,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,KAAK,UAAU,GAChB,MAAM,2BAA2B,CAAC"}

package/dist/emergent/index.js

@@ -25,4 +25,13 @@ export { ManageSkillsTool } from './ManageSkillsTool.js';
 export { CreateWorkflowTool } from './CreateWorkflowTool.js';
 export { SelfEvaluateTool } from './SelfEvaluateTool.js';
 export { PersonalityMutationStore } from './PersonalityMutationStore.js';
+// Forge observability — instrumentation for consumers that want live
+// visibility into forge health (rejection-reason histogram, shape-check
+// pre-validator, schema inference from testCases, capture wrapper,
+// aggregator).
+export { classifyForgeRejection, } from './ForgeRejectionClassifier.js';
+export { validateForgeShape, } from './ForgeShapeValidator.js';
+export { inferSchemaFromTestCases, } from './ForgeSchemaInference.js';
+export { wrapForgeTool, } from './wrapForgeTool.js';
+export { ForgeStatsAggregator, emptyForgeStats, } from './ForgeStatsAggregator.js';
 //# sourceMappingURL=index.js.map

package/dist/emergent/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/emergent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAA8B,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EACL,oCAAoC,EACpC,wBAAwB,EACxB,4BAA4B,EAC5B,wBAAwB,EACxB,kCAAkC,GACnC,MAAM,kBAAkB,CAAC;AAQ1B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/emergent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAA8B,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAKjE,OAAO,EACL,oCAAoC,EACpC,wBAAwB,EACxB,4BAA4B,EAC5B,wBAAwB,EACxB,kCAAkC,GACnC,MAAM,kBAAkB,CAAC;AAQ1B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAIzE,qEAAqE;AACrE,wEAAwE;AACxE,mEAAmE;AACnE,eAAe;AACf,OAAO,EACL,sBAAsB,GAEvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,GAEnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,wBAAwB,GAEzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,aAAa,GAId,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,oBAAoB,EACpB,eAAe,GAEhB,MAAM,2BAA2B,CAAC"}

package/dist/emergent/wrapForgeTool.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Wrapper around ForgeToolMetaTool that normalizes LLM
+ * output, runs a pre-judge shape check, captures every attempt, and
+ * surfaces outcomes as structured log events.
+ * @module @framers/agentos/emergent/wrapForgeTool
+ *
+ * LLMs emit wide variety in forge_tool args (stringified JSON, wrong
+ * mode spellings, missing allowlists, no code body). This wrapper fixes
+ * them up so the engine never crashes deep in sandbox validation, and
+ * every attempt gets recorded to the caller's capture sink regardless
+ * of outcome. That gives consumers an attempt-level ground truth that
+ * does not depend on the LLM self-reporting its forge calls.
+ *
+ * Pure wrapper over ForgeToolMetaTool + ForgeShapeValidator +
+ * ForgeSchemaInference. No stdout dependency — log events route
+ * through the optional `log` callback.
+ */
+import type { ITool } from '../core/tools/ITool.js';
+import { ForgeToolMetaTool } from './ForgeToolMetaTool.js';
+/**
+ * Captured forge event — ground-truth record of an actual forge call,
+ * independent of whether the LLM self-reported it.
+ */
+export interface CapturedForge {
+    /** Tool name (`fixed.name || 'unnamed'`). */
+    name: string;
+    /** Tool description (`fixed.description || name`). */
+    description: string;
+    /** `'sandbox'` or `'compose'` after normalization. */
+    mode: string;
+    /** Forge request's declared input schema post-normalization. */
+    inputSchema: unknown;
+    /** Forge request's declared output schema post-normalization. */
+    outputSchema: unknown;
+    /** Did the judge approve? */
+    approved: boolean;
+    /** Judge confidence for approved tools; 0 on rejection. */
+    confidence: number;
+    /** Judge verdict payload or shape-check context. */
+    output: unknown;
+    /** Populated on rejection or error. Truncated to 240 chars. */
+    errorReason?: string;
+    /**
+     * Optional free-form scope label (e.g. a department name, a chat
+     * agent id, or any grouping the caller wants propagated onto every
+     * capture record). Left undefined when the caller does not group.
+     */
+    scope?: string;
+    /** Wall-clock ms so captures can be attributed to surrounding events. */
+    timestamp: number;
+}
+/**
+ * Structured log event emitted at each forge lifecycle step. Consumers
+ * who care about stdout visibility can pass a `log` callback that
+ * renders this into console.log / pm2 / whatever. AgentOS emits
+ * nothing by default so the wrapper is safe to use in quiet contexts.
+ */
+export type ForgeLogEvent = {
+    kind: 'start';
+    scope?: string;
+    toolName: string;
+    mode: string;
+} | {
+    kind: 'approved';
+    scope?: string;
+    toolName: string;
+    confidence: number;
+} | {
+    kind: 'rejected';
+    scope?: string;
+    toolName: string;
+    reason: string;
+} | {
+    kind: 'error';
+    scope?: string;
+    toolName: string;
+    error: string;
+};
+/** Options for {@link wrapForgeTool}. */
+export interface WrapForgeToolOptions {
+    /** The raw ForgeToolMetaTool instance from EmergentCapabilityEngine. */
+    raw: ForgeToolMetaTool;
+    /** GMI / agent id patched onto the tool execution context. */
+    agentId: string;
+    /** Session id patched onto the tool execution context under sessionData. */
+    sessionId: string;
+    /** Required capture sink. Every attempt (valid or not) is recorded. */
+    capture: (record: CapturedForge) => void;
+    /**
+     * Optional scope label propagated onto every CapturedForge. Use for
+     * semantic grouping when multiple callers share a wrapper (dept
+     * name, channel id, agent role, etc.).
+     */
+    scope?: string;
+    /**
+     * Optional log callback for lifecycle visibility. When undefined,
+     * no log events are emitted (quiet mode).
+     */
+    log?: (event: ForgeLogEvent) => void;
+}
+/**
+ * Wrap the raw ForgeToolMetaTool so each forge attempt gets normalized,
+ * pre-validated, captured, and logged.
+ *
+ * Normalization fixes: stringified-JSON fields, mode synonyms (`code`,
+ * `javascript`, `js` → `sandbox`; `composed`, `composition`, `chain`,
+ * `pipeline` → `compose`), missing allowlist / code body / steps /
+ * schemas / testCases. After normalization, the shape validator runs;
+ * on failure the judge is skipped and a rejection record is captured
+ * immediately. On success, the raw meta-tool executes and the result's
+ * verdict is folded into a capture record.
+ */
+export declare function wrapForgeTool(options: WrapForgeToolOptions): ITool;
+//# sourceMappingURL=wrapForgeTool.d.ts.map

package/dist/emergent/wrapForgeTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapForgeTool.d.ts","sourceRoot":"","sources":["../../src/emergent/wrapForgeTool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAwB,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAuB,MAAM,wBAAwB,CAAC;AAIhF;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,iEAAiE;IACjE,YAAY,EAAE,OAAO,CAAC;IACtB,6BAA6B;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,MAAM,EAAE,OAAO,CAAC;IAChB,+DAA+D;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACjE;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACtE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,yCAAyC;AACzC,MAAM,WAAW,oBAAoB;IACnC,wEAAwE;IACxE,GAAG,EAAE,iBAAiB,CAAC;IACvB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,OAAO,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;IACzC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CACtC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,KAAK,CA2LlE"}

package/dist/emergent/wrapForgeTool.js

@@ -0,0 +1,219 @@
+/**
+ * @fileoverview Wrapper around ForgeToolMetaTool that normalizes LLM
+ * output, runs a pre-judge shape check, captures every attempt, and
+ * surfaces outcomes as structured log events.
+ * @module @framers/agentos/emergent/wrapForgeTool
+ *
+ * LLMs emit wide variety in forge_tool args (stringified JSON, wrong
+ * mode spellings, missing allowlists, no code body). This wrapper fixes
+ * them up so the engine never crashes deep in sandbox validation, and
+ * every attempt gets recorded to the caller's capture sink regardless
+ * of outcome. That gives consumers an attempt-level ground truth that
+ * does not depend on the LLM self-reporting its forge calls.
+ *
+ * Pure wrapper over ForgeToolMetaTool + ForgeShapeValidator +
+ * ForgeSchemaInference. No stdout dependency — log events route
+ * through the optional `log` callback.
+ */
+import { validateForgeShape } from './ForgeShapeValidator.js';
+import { inferSchemaFromTestCases } from './ForgeSchemaInference.js';
+/**
+ * Wrap the raw ForgeToolMetaTool so each forge attempt gets normalized,
+ * pre-validated, captured, and logged.
+ *
+ * Normalization fixes: stringified-JSON fields, mode synonyms (`code`,
+ * `javascript`, `js` → `sandbox`; `composed`, `composition`, `chain`,
+ * `pipeline` → `compose`), missing allowlist / code body / steps /
+ * schemas / testCases. After normalization, the shape validator runs;
+ * on failure the judge is skipped and a rejection record is captured
+ * immediately. On success, the raw meta-tool executes and the result's
+ * verdict is folded into a capture record.
+ */
+export function wrapForgeTool(options) {
+    const { raw, agentId, sessionId, capture, scope, log } = options;
+    return {
+        ...raw,
+        async execute(args, ctx) {
+            const fixed = { ...args };
+            for (const k of ['implementation', 'inputSchema', 'outputSchema', 'testCases']) {
+                if (typeof fixed[k] === 'string') {
+                    try {
+                        fixed[k] = JSON.parse(fixed[k]);
+                    }
+                    catch {
+                        // Leave as-is; downstream normalization backstops most failures.
+                    }
+                }
+            }
+            // Normalize implementation. Strict `mode === 'compose'` check in
+            // the engine means anything else falls into the sandbox branch.
+            // Unfamiliar mode strings + missing fields can crash deep in
+            // SandboxedToolForge.validateCode. Normalize to exactly
+            // 'sandbox' or 'compose', infer from field shape when the mode
+            // string is unfamiliar, backstop every required field.
+            if (fixed.implementation && typeof fixed.implementation === 'object') {
+                const impl = fixed.implementation;
+                if (impl.mode === 'code' || impl.mode === 'javascript' || impl.mode === 'js') {
+                    impl.mode = 'sandbox';
+                }
+                if (impl.mode === 'composed' ||
+                    impl.mode === 'composition' ||
+                    impl.mode === 'composable' ||
+                    impl.mode === 'chain' ||
+                    impl.mode === 'pipeline') {
+                    impl.mode = 'compose';
+                }
+                if (impl.mode !== 'sandbox' && impl.mode !== 'compose') {
+                    if (Array.isArray(impl.steps))
+                        impl.mode = 'compose';
+                    else if (typeof impl.code === 'string')
+                        impl.mode = 'sandbox';
+                    else
+                        impl.mode = 'sandbox';
+                }
+                if (impl.mode === 'sandbox') {
+                    if (!Array.isArray(impl.allowlist))
+                        impl.allowlist = [];
+                    if (impl.code != null && typeof impl.code !== 'string')
+                        impl.code = String(impl.code);
+                    if (!impl.code || typeof impl.code !== 'string') {
+                        impl.code = 'function execute(input) { return { error: "No code provided in forge request" }; }';
+                    }
+                    if (!impl.code.includes('function execute')) {
+                        impl.code = `function execute(input) {\n${impl.code}\n}`;
+                    }
+                }
+                else if (impl.mode === 'compose') {
+                    if (!Array.isArray(impl.steps))
+                        impl.steps = [];
+                    for (const step of impl.steps) {
+                        if (step && typeof step === 'object') {
+                            if (typeof step.tool !== 'string')
+                                step.tool = '';
+                            if (typeof step.name !== 'string')
+                                step.name = step.tool || 'step';
+                            if (!step.inputMapping || typeof step.inputMapping !== 'object') {
+                                step.inputMapping = {};
+                            }
+                        }
+                    }
+                }
+            }
+            if (!fixed.inputSchema || typeof fixed.inputSchema !== 'object') {
+                fixed.inputSchema = { type: 'object', additionalProperties: true };
+            }
+            if (!fixed.outputSchema || typeof fixed.outputSchema !== 'object') {
+                fixed.outputSchema = { type: 'object', additionalProperties: true };
+            }
+            if (!Array.isArray(fixed.testCases) || fixed.testCases.length === 0) {
+                fixed.testCases = [{ input: {}, expectedOutput: {} }];
+            }
+            for (const tc of fixed.testCases) {
+                if (!tc.input || typeof tc.input !== 'object')
+                    tc.input = {};
+                if (tc.expectedOutput === undefined)
+                    tc.expectedOutput = {};
+            }
+            // Rescue concrete-testCases-without-formal-schema forges. Still
+            // strict: tool code must handle the inferred inputs, but the
+            // shape check passes deterministically on intent-clear input.
+            inferSchemaFromTestCases(fixed);
+            const mode = String(fixed.implementation?.mode ?? '?');
+            const toolName = String(fixed.name ?? 'unnamed');
+            const toolDescription = String(fixed.description ?? toolName);
+            // Pre-judge shape check. On failure, capture + emit a rejection
+            // event and short-circuit without invoking the judge LLM.
+            const shapeErrors = validateForgeShape(fixed);
+            if (shapeErrors.length > 0) {
+                const reason = `Shape check failed: ${shapeErrors.join('; ')}`;
+                log?.({ kind: 'rejected', scope, toolName, reason });
+                capture({
+                    name: toolName,
+                    description: toolDescription,
+                    mode,
+                    inputSchema: fixed.inputSchema,
+                    outputSchema: fixed.outputSchema,
+                    approved: false,
+                    confidence: 0,
+                    output: null,
+                    errorReason: reason.slice(0, 240),
+                    scope,
+                    timestamp: Date.now(),
+                });
+                return {
+                    success: false,
+                    error: reason,
+                    output: { success: false, verdict: { approved: false, confidence: 0, reasoning: reason } },
+                };
+            }
+            log?.({ kind: 'start', scope, toolName, mode });
+            const patched = {
+                ...ctx,
+                gmiId: agentId,
+                sessionData: {
+                    ...(ctx?.sessionData ?? {}),
+                    sessionId,
+                },
+            };
+            try {
+                // Cast is intentional: the wrapper's job is to normalize
+                // arbitrary LLM output into something the engine can handle.
+                // By this point `fixed` is shape-validated enough to run; TS
+                // cannot statically prove it matches every ForgeToolInput
+                // field because the source is untyped LLM output.
+                const r = await raw.execute(fixed, patched);
+                const out = r.output;
+                const verdict = out?.verdict ?? {};
+                // Judge confidence is the judge's score for whether the tool is
+                // safe + correct. When rejected, the judge's confidence is in
+                // REJECTING the tool; surfacing that as the tool's own quality
+                // score would be misleading. So: approved → judge confidence (or
+                // 0.85 fallback); rejected → 0.
+                const judgeConfidence = typeof verdict.confidence === 'number' ? verdict.confidence : null;
+                const confidence = r.success ? (judgeConfidence ?? 0.85) : 0;
+                const errorReason = !r.success
+                    ? String(r.error ?? verdict.reasoning ?? out?.error ?? '').slice(0, 240)
+                    : undefined;
+                if (r.success) {
+                    log?.({ kind: 'approved', scope, toolName, confidence });
+                }
+                else {
+                    log?.({ kind: 'rejected', scope, toolName, reason: errorReason ?? '' });
+                }
+                capture({
+                    name: toolName,
+                    description: toolDescription,
+                    mode,
+                    inputSchema: fixed.inputSchema,
+                    outputSchema: fixed.outputSchema,
+                    approved: !!r.success,
+                    confidence,
+                    output: out?.testResults ?? out?.result ?? out ?? null,
+                    errorReason,
+                    scope,
+                    timestamp: Date.now(),
+                });
+                return r;
+            }
+            catch (err) {
+                const message = String(err).slice(0, 240);
+                log?.({ kind: 'error', scope, toolName, error: message });
+                capture({
+                    name: toolName,
+                    description: toolDescription,
+                    mode,
+                    inputSchema: fixed.inputSchema,
+                    outputSchema: fixed.outputSchema,
+                    approved: false,
+                    confidence: 0,
+                    output: null,
+                    errorReason: message,
+                    scope,
+                    timestamp: Date.now(),
+                });
+                return { success: false, error: String(err) };
+            }
+        },
+    };
+}
+//# sourceMappingURL=wrapForgeTool.js.map

package/dist/emergent/wrapForgeTool.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@framers/agentos",
-  "version": "0.1.229",
+  "version": "0.1.230",
   "description": "Modular AgentOS orchestration library",
   "type": "module",
   "main": "dist/index.js",