@open-agent-toolkit/cli 0.1.43 → 0.1.45

package/dist/config/oat-config.js

@@ -21,6 +21,7 @@ export const VALID_CLAUDE_DISPATCH_CEILINGS = ['haiku', 'sonnet', 'opus', 'fable
 export const VALID_DISPATCH_CEILING_PRESETS = ['balanced', 'maximum', 'cost-conscious'];
 export const VALID_DISPATCH_POLICY_MODES = ['managed', 'inherit'];
 export const VALID_MANAGED_DISPATCH_POLICIES = ['economy', 'balanced', 'high', 'frontier', 'uncapped'];
+export const VALID_DISPATCH_MATRIX_TIERS = ['economy', 'balanced', 'high', 'frontier'];
 const VALID_GATE_ON_FAILURES = [
     'block',
     'prompt',
@@ -49,7 +50,11 @@ export const BUILTIN_EXEC_TARGETS = {
         runtime: 'cursor',
         baseCommand: ['cursor-agent', '-p'],
         hostDetectionCommand: ['sh', '-c', 'test -n "$CURSOR_AGENT"'],
-        availabilityCommand: ['cursor-agent', '--version'],
+        availabilityCommand: [
+            'sh',
+            '-c',
+            'command -v cursor-agent || command -v agent',
+        ],
         priority: 70,
     },
 };
@@ -72,6 +77,14 @@ function normalizeArgv(value) {
     }
     return [...value];
 }
+function normalizeStringList(value) {
+    if (!Array.isArray(value) ||
+        value.length === 0 ||
+        !value.every((item) => typeof item === 'string' && item.trim().length > 0)) {
+        return undefined;
+    }
+    return value.map((item) => item.trim());
+}
 function normalizeGateConfig(value) {
     if (value === null) {
         return null;
@@ -96,6 +109,82 @@ function normalizeGateConfig(value) {
     }
     return gate;
 }
+function normalizeProviderBareValue(providerKey, value) {
+    const trimmed = trimNonEmptyString(value);
+    if (trimmed === undefined) {
+        return undefined;
+    }
+    if (providerKey === 'codex' &&
+        !VALID_CODEX_DISPATCH_CEILINGS.includes(trimmed)) {
+        return undefined;
+    }
+    if (providerKey === 'claude' &&
+        !VALID_CLAUDE_DISPATCH_CEILINGS.includes(trimmed)) {
+        return undefined;
+    }
+    return trimmed;
+}
+function normalizeDispatchRouteTarget(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const target = {};
+    const harness = trimNonEmptyString(value.harness);
+    if (harness !== undefined) {
+        target.harness = harness;
+    }
+    const model = trimNonEmptyString(value.model);
+    if (model !== undefined) {
+        target.model = model;
+    }
+    const effort = trimNonEmptyString(value.effort);
+    if (effort !== undefined) {
+        target.effort = effort;
+    }
+    return Object.keys(target).length > 0 ? target : undefined;
+}
+function normalizeDispatchMatrixCell(providerKey, value) {
+    const bareValue = normalizeProviderBareValue(providerKey, value);
+    if (bareValue !== undefined) {
+        return bareValue;
+    }
+    if (!Array.isArray(value) || value.length === 0) {
+        return undefined;
+    }
+    const route = [];
+    for (const entry of value) {
+        const bareEntry = normalizeProviderBareValue(providerKey, entry);
+        if (bareEntry !== undefined) {
+            route.push(bareEntry);
+            continue;
+        }
+        const target = normalizeDispatchRouteTarget(entry);
+        if (target !== undefined) {
+            route.push(target);
+        }
+    }
+    return route.length > 0 ? route : undefined;
+}
+function normalizeDispatchProviderValue(providerKey, value) {
+    const bareValue = normalizeProviderBareValue(providerKey, value);
+    if (bareValue !== undefined) {
+        return bareValue;
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const tierMap = {};
+    for (const [tier, rawCell] of Object.entries(value)) {
+        if (!VALID_DISPATCH_MATRIX_TIERS.includes(tier)) {
+            continue;
+        }
+        const normalized = normalizeDispatchMatrixCell(providerKey, rawCell);
+        if (normalized !== undefined) {
+            tierMap[tier] = normalized;
+        }
+    }
+    return Object.keys(tierMap).length > 0 ? tierMap : undefined;
+}
 function normalizeExecTarget(value) {
     if (value === null) {
         return null;
@@ -112,6 +201,10 @@ function normalizeExecTarget(value) {
     if (baseCommand !== undefined) {
         target.baseCommand = baseCommand;
     }
+    const models = normalizeStringList(value.models);
+    if (models !== undefined) {
+        target.models = models;
+    }
     if ('priority' in value) {
         if (typeof value.priority === 'number' && Number.isFinite(value.priority)) {
             target.priority = value.priority;
@@ -215,17 +308,17 @@ function normalizeWorkflowConfig(parsed) {
             dispatchCeiling.preset = parsed.dispatchCeiling
                 .preset;
         }
+        const recommendationVersion = trimNonEmptyString(parsed.dispatchCeiling.recommendationVersion);
+        if (recommendationVersion !== undefined) {
+            dispatchCeiling.recommendationVersion = recommendationVersion;
+        }
         if (isRecord(parsed.dispatchCeiling.providers)) {
             const providers = {};
-            if (typeof parsed.dispatchCeiling.providers.codex === 'string' &&
-                VALID_CODEX_DISPATCH_CEILINGS.includes(parsed.dispatchCeiling.providers.codex)) {
-                providers.codex = parsed.dispatchCeiling.providers
-                    .codex;
-            }
-            if (typeof parsed.dispatchCeiling.providers.claude === 'string' &&
-                VALID_CLAUDE_DISPATCH_CEILINGS.includes(parsed.dispatchCeiling.providers.claude)) {
-                providers.claude = parsed.dispatchCeiling.providers
-                    .claude;
+            for (const [providerKey, rawProviderValue] of Object.entries(parsed.dispatchCeiling.providers)) {
+                const normalized = normalizeDispatchProviderValue(providerKey, rawProviderValue);
+                if (normalized !== undefined) {
+                    providers[providerKey] = normalized;
+                }
             }
             if (Object.keys(providers).length > 0) {
                 dispatchCeiling.providers = providers;

package/dist/config/resolve.js

@@ -181,6 +181,7 @@ function mergeExecTargetLayer(targets, layer) {
             targets[id] = cloneExecTarget({
                 runtime: override.runtime ?? existing.runtime,
                 baseCommand: override.baseCommand ?? existing.baseCommand,
+                models: override.models ?? existing.models,
                 hostDetectionCommand: override.hostDetectionCommand ?? existing.hostDetectionCommand,
                 availabilityCommand: override.availabilityCommand ?? existing.availabilityCommand,
                 priority: override.priority ?? existing.priority,
@@ -211,6 +212,9 @@ function cloneExecTarget(target) {
     if (target.availabilityCommand) {
         next.availabilityCommand = [...target.availabilityCommand];
     }
+    if (target.models) {
+        next.models = [...target.models];
+    }
     return next;
 }
 function toCompleteExecTarget(target) {
@@ -231,8 +235,16 @@ function toCompleteExecTarget(target) {
     if (isValidArgv(target.availabilityCommand)) {
         completeTarget.availabilityCommand = [...target.availabilityCommand];
     }
+    if (isValidStringList(target.models)) {
+        completeTarget.models = target.models.map((model) => model.trim());
+    }
     return completeTarget;
 }
+function isValidStringList(value) {
+    return (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((part) => typeof part === 'string' && part.trim().length > 0));
+}
 function isValidArgv(value) {
     if (!Array.isArray(value) ||
         value.length === 0 ||

package/dist/manifest/manifest.types.d.ts

@@ -9,36 +9,36 @@ export declare const ManifestEntrySchema: z.ZodEffects<z.ZodObject<{
     isFile: z.ZodDefault<z.ZodBoolean>;
     lastSynced: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    provider: string;
     canonicalPath: string;
     providerPath: string;
-    provider: string;
     contentType: "skill" | "agent" | "rule";
     strategy: "symlink" | "copy";
     contentHash: string | null;
     isFile: boolean;
     lastSynced: string;
 }, {
+    provider: string;
     canonicalPath: string;
     providerPath: string;
-    provider: string;
     contentType: "skill" | "agent" | "rule";
     strategy: "symlink" | "copy";
     contentHash: string | null;
     lastSynced: string;
     isFile?: boolean | undefined;
 }>, {
+    provider: string;
     canonicalPath: string;
     providerPath: string;
-    provider: string;
     contentType: "skill" | "agent" | "rule";
     strategy: "symlink" | "copy";
     contentHash: string | null;
     isFile: boolean;
     lastSynced: string;
 }, {
+    provider: string;
     canonicalPath: string;
     providerPath: string;
-    provider: string;
     contentType: "skill" | "agent" | "rule";
     strategy: "symlink" | "copy";
     contentHash: string | null;
@@ -58,36 +58,36 @@ export declare const ManifestSchema: z.ZodEffects<z.ZodObject<{
         isFile: z.ZodDefault<z.ZodBoolean>;
         lastSynced: z.ZodString;
     }, "strip", z.ZodTypeAny, {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;
         isFile: boolean;
         lastSynced: string;
     }, {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;
         lastSynced: string;
         isFile?: boolean | undefined;
     }>, {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;
         isFile: boolean;
         lastSynced: string;
     }, {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;
@@ -97,9 +97,9 @@ export declare const ManifestSchema: z.ZodEffects<z.ZodObject<{
     lastUpdated: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     entries: {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;
@@ -111,9 +111,9 @@ export declare const ManifestSchema: z.ZodEffects<z.ZodObject<{
     lastUpdated: string;
 }, {
     entries: {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;
@@ -125,9 +125,9 @@ export declare const ManifestSchema: z.ZodEffects<z.ZodObject<{
     lastUpdated: string;
 }>, {
     entries: {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;
@@ -139,9 +139,9 @@ export declare const ManifestSchema: z.ZodEffects<z.ZodObject<{
     lastUpdated: string;
 }, {
     entries: {
+        provider: string;
         canonicalPath: string;
         providerPath: string;
-        provider: string;
         contentType: "skill" | "agent" | "rule";
         strategy: "symlink" | "copy";
         contentHash: string | null;

package/dist/providers/ceiling/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/providers/ceiling/registry.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG,WAAW,GAAG,MAAM,CAAC;AAE3E,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,UAAU,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACjB,IAAI,CAAC;AAET,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,oBAAoB,CAAC;IAChC;;;OAGG;IACH,qBAAqB,CACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,qBAAqB,GACzB,mBAAmB,CAAC;IACvB;;;;OAIG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC;CACtE;AAMD,wEAAwE;AACxE,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAK9C,CAAC;AA0EF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB,CAE1E"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/providers/ceiling/registry.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,GAAG,WAAW,GAAG,MAAM,CAAC;AAE3E,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,UAAU,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACjB,IAAI,CAAC;AAET,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,oBAAoB,CAAC;IAChC;;;OAGG;IACH,qBAAqB,CACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,qBAAqB,GACzB,mBAAmB,CAAC;IACvB;;;;OAIG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC;CACtE;AAMD,wEAAwE;AACxE,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAK9C,CAAC;AA2FF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,sBAAsB,CAE1E"}

package/dist/providers/ceiling/registry.js

@@ -54,6 +54,21 @@ const claudeAdapter = {
         return isAboveOrchestrator(value, ctx.orchestratorTier);
     },
 };
+const cursorAdapter = {
+    provider: 'cursor',
+    supportsCeiling: true,
+    validValues: [],
+    mechanism: 'model-arg',
+    compileToDispatchArgs(value) {
+        const model = value.trim();
+        return model ? { model } : null;
+    },
+    // Cursor model slugs do not share a total order, so upgrade verification is
+    // not meaningful here; availability is checked by the identity oracle layer.
+    verifyOnDispatch() {
+        return false;
+    },
+};
 function advisoryAdapter(provider) {
     return {
         provider,
@@ -71,6 +86,7 @@ function advisoryAdapter(provider) {
 const REGISTERED_ADAPTERS = {
     codex: codexAdapter,
     claude: claudeAdapter,
+    cursor: cursorAdapter,
 };
 /**
  * Look up the ceiling adapter for a provider. Unknown providers fall back to an

package/dist/providers/identity/availability.d.ts

@@ -0,0 +1,22 @@
+export type MatrixCellAvailability = 'valid' | 'unknown-value' | 'unvalidated';
+export interface CursorAgentRunOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export interface CursorAgentRunResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}
+export interface AvailabilityOracleDependencies {
+    pathExists: (path: string) => Promise<boolean>;
+    runCursorAgent: (args: string[], options: CursorAgentRunOptions) => Promise<CursorAgentRunResult>;
+    env?: NodeJS.ProcessEnv;
+}
+export interface ValidateMatrixCellOptions {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    dependencies?: Partial<AvailabilityOracleDependencies>;
+}
+export declare function validateMatrixCell(provider: string, value: string, options: ValidateMatrixCellOptions): Promise<MatrixCellAvailability>;
+//# sourceMappingURL=availability.d.ts.map

package/dist/providers/identity/availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/availability.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,eAAe,GAAG,aAAa,CAAC;AAE/E,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,8BAA8B;IAC7C,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,cAAc,EAAE,CACd,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC,8BAA8B,CAAC,CAAC;CACxD;AAwID,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,sBAAsB,CAAC,CA8BjC"}

package/dist/providers/identity/availability.js

@@ -0,0 +1,119 @@
+import { execFile } from 'node:child_process';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { VALID_CLAUDE_DISPATCH_CEILINGS, VALID_CODEX_DISPATCH_CEILINGS, } from '../../config/oat-config.js';
+import { fileExists } from '../../fs/io.js';
+const execFileAsync = promisify(execFile);
+async function runCursorAgent(args, options) {
+    try {
+        const { stdout, stderr } = await execFileAsync('cursor-agent', args, {
+            cwd: options.cwd,
+            env: options.env,
+            maxBuffer: 1024 * 1024,
+            timeout: 10_000,
+        });
+        return {
+            ok: true,
+            stdout: String(stdout),
+            stderr: String(stderr),
+        };
+    }
+    catch (error) {
+        const failure = error;
+        return {
+            ok: false,
+            stdout: String(failure.stdout ?? ''),
+            stderr: String(failure.stderr ?? failure.message),
+        };
+    }
+}
+const DEFAULT_DEPENDENCIES = {
+    pathExists: fileExists,
+    runCursorAgent,
+    env: process.env,
+};
+function apiKeyArgs(env) {
+    const apiKey = env.CURSOR_API_KEY;
+    return typeof apiKey === 'string' && apiKey.length > 0
+        ? ['--api-key', apiKey]
+        : [];
+}
+function parseCursorCatalog(stdout) {
+    const entries = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const match = line.match(/^(\S+)\s+-\s+(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const [, slug] = match;
+        if (slug) {
+            entries.push({ slug });
+        }
+    }
+    return entries;
+}
+function availabilityFromCursorCatalog(value, stdout) {
+    const entries = parseCursorCatalog(stdout);
+    if (entries.length === 0) {
+        return null;
+    }
+    return entries.some((entry) => entry.slug === value)
+        ? 'valid'
+        : 'unknown-value';
+}
+async function validateCodexCell(value, cwd, dependencies) {
+    if (!VALID_CODEX_DISPATCH_CEILINGS.includes(value)) {
+        return 'unknown-value';
+    }
+    try {
+        const implementerExists = await dependencies.pathExists(join(cwd, '.codex', 'agents', `oat-phase-implementer-${value}.toml`));
+        const reviewerExists = await dependencies.pathExists(join(cwd, '.codex', 'agents', `oat-reviewer-${value}.toml`));
+        return implementerExists && reviewerExists ? 'valid' : 'unknown-value';
+    }
+    catch {
+        return 'unvalidated';
+    }
+}
+async function validateCursorCell(value, cwd, dependencies) {
+    const env = dependencies.env ?? process.env;
+    const runOptions = { cwd, env };
+    const modelsResult = await dependencies.runCursorAgent([...apiKeyArgs(env), 'models'], runOptions);
+    if (modelsResult.ok) {
+        const availability = availabilityFromCursorCatalog(value, modelsResult.stdout);
+        if (availability !== null) {
+            return availability;
+        }
+    }
+    const listResult = await dependencies.runCursorAgent([...apiKeyArgs(env), '--list-models'], runOptions);
+    if (listResult.ok) {
+        const availability = availabilityFromCursorCatalog(value, listResult.stdout);
+        if (availability !== null) {
+            return availability;
+        }
+    }
+    return 'unvalidated';
+}
+export async function validateMatrixCell(provider, value, options) {
+    const normalizedProvider = provider.trim().toLowerCase();
+    const normalizedValue = value.trim();
+    if (!normalizedProvider || !normalizedValue) {
+        return 'unknown-value';
+    }
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        env: options.env ?? DEFAULT_DEPENDENCIES.env,
+        ...options.dependencies,
+    };
+    if (normalizedProvider === 'claude') {
+        return VALID_CLAUDE_DISPATCH_CEILINGS.includes(normalizedValue)
+            ? 'valid'
+            : 'unknown-value';
+    }
+    if (normalizedProvider === 'codex') {
+        return validateCodexCell(normalizedValue, options.cwd, dependencies);
+    }
+    if (normalizedProvider === 'cursor') {
+        return validateCursorCell(normalizedValue, options.cwd, dependencies);
+    }
+    return 'unvalidated';
+}

package/dist/providers/identity/family.d.ts

@@ -0,0 +1,13 @@
+export type ModelFamily = 'claude' | 'openai' | 'composer' | 'glm' | 'unknown';
+interface ClassifyModelFamilyInput {
+    value: string;
+    /**
+     * Structured model-provider identifier, when a harness exposes one. This is
+     * not the orchestration/runtime harness id; e.g. Cursor can run several model
+     * families and must be classified from the concrete model value.
+     */
+    providerId?: string;
+}
+export declare function classifyModelFamily(input: ClassifyModelFamilyInput): ModelFamily;
+export {};
+//# sourceMappingURL=family.d.ts.map

package/dist/providers/identity/family.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"family.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/family.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,KAAK,GAAG,SAAS,CAAC;AAE/E,UAAU,wBAAwB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAgCD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,wBAAwB,GAC9B,WAAW,CASb"}

package/dist/providers/identity/family.js

@@ -0,0 +1,32 @@
+const PROVIDER_ID_FAMILIES = [
+    [/^(anthropic|claude)$/i, 'claude'],
+    [/^(openai|codex)$/i, 'openai'],
+    [/^composer$/i, 'composer'],
+    [/^(glm|zai|zhipu)$/i, 'glm'],
+];
+const VALUE_FAMILIES = [
+    [/\b(claude|sonnet|opus|haiku|fable)\b/i, 'claude'],
+    [/\b(gpt|openai|codex|o[1-9])[-\w.]*\b/i, 'openai'],
+    [/\bcomposer\b/i, 'composer'],
+    [/\bglm\b/i, 'glm'],
+];
+function normalize(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function firstMatchingFamily(value, patterns) {
+    for (const [pattern, family] of patterns) {
+        if (pattern.test(value)) {
+            return family;
+        }
+    }
+    return undefined;
+}
+export function classifyModelFamily(input) {
+    const providerId = normalize(input?.providerId);
+    const providerFamily = firstMatchingFamily(providerId, PROVIDER_ID_FAMILIES);
+    if (providerFamily) {
+        return providerFamily;
+    }
+    const value = normalize(input?.value);
+    return firstMatchingFamily(value, VALUE_FAMILIES) ?? 'unknown';
+}

package/dist/providers/identity/provenance.d.ts

@@ -0,0 +1,21 @@
+export type IdentityProvenance = 'declared' | 'observed' | 'inferred' | 'unknown';
+export type IdentityConfidence = 'high' | 'medium' | 'low' | 'unknown';
+export interface IdentityRecord {
+    value: string;
+    provenance: IdentityProvenance;
+    /**
+     * True when the harness has been proven to reject invalid model selections
+     * instead of silently falling back to another model.
+     */
+    rejectOnInvalid?: boolean;
+}
+export interface ResolvedIdentity {
+    value: string;
+    provenance: IdentityProvenance;
+    confidence: IdentityConfidence;
+    mismatch: boolean;
+    diversityClaimable: boolean;
+    records: IdentityRecord[];
+}
+export declare function resolveIdentityConfidence(records: IdentityRecord[]): ResolvedIdentity;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/providers/identity/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/provenance.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,UAAU,GACV,UAAU,GACV,SAAS,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;AAEvE,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,kBAAkB,CAAC;IAC/B;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,kBAAkB,CAAC;IAC/B,UAAU,EAAE,kBAAkB,CAAC;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,OAAO,EAAE,cAAc,EAAE,CAAC;CAC3B;AA+DD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,cAAc,EAAE,GACxB,gBAAgB,CAmClB"}

package/dist/providers/identity/provenance.js

@@ -0,0 +1,65 @@
+const PROVENANCE_PRIORITY = {
+    declared: 4,
+    observed: 3,
+    inferred: 2,
+    unknown: 1,
+};
+function normalizedValue(value) {
+    return typeof value === 'string' && value.trim().length > 0
+        ? value.trim()
+        : 'unknown';
+}
+function normalizeRecord(record) {
+    return {
+        ...record,
+        value: normalizedValue(record.value),
+    };
+}
+function strongestRecord(records, provenance) {
+    return records.find((record) => record.provenance === provenance && record.value !== 'unknown');
+}
+function strongestKnownRecord(records) {
+    return records
+        .filter((record) => record.value !== 'unknown')
+        .sort((left, right) => PROVENANCE_PRIORITY[right.provenance] -
+        PROVENANCE_PRIORITY[left.provenance])[0];
+}
+function resolved(record, confidence, mismatch, records) {
+    const value = record.value;
+    return {
+        value,
+        provenance: record.provenance,
+        confidence,
+        mismatch,
+        diversityClaimable: value !== 'unknown' &&
+            record.provenance !== 'unknown' &&
+            confidence !== 'unknown',
+        records,
+    };
+}
+export function resolveIdentityConfidence(records) {
+    const normalizedRecords = records.map(normalizeRecord);
+    const declared = strongestRecord(normalizedRecords, 'declared');
+    const observed = strongestRecord(normalizedRecords, 'observed');
+    if (declared && observed) {
+        if (declared.value === observed.value) {
+            return resolved(declared, 'high', false, normalizedRecords);
+        }
+        return resolved(observed, 'low', true, normalizedRecords);
+    }
+    if (declared) {
+        return resolved(declared, declared.rejectOnInvalid === true ? 'high' : 'medium', false, normalizedRecords);
+    }
+    if (observed) {
+        return resolved(observed, 'low', false, normalizedRecords);
+    }
+    const inferred = strongestRecord(normalizedRecords, 'inferred');
+    if (inferred) {
+        return resolved(inferred, 'low', false, normalizedRecords);
+    }
+    const fallback = strongestKnownRecord(normalizedRecords) ?? {
+        value: 'unknown',
+        provenance: 'unknown',
+    };
+    return resolved(fallback, 'unknown', false, normalizedRecords);
+}

package/dist/providers/identity/stamp.d.ts

@@ -0,0 +1,35 @@
+import type { IdentityProvenance } from './provenance.js';
+export type DispatchAction = 'implementation' | 'fix' | 'review';
+export type DispatchRole = 'implementer' | 'fix' | 'reviewer';
+export interface DispatchStampRecord {
+    scope: string;
+    action: DispatchAction;
+    role: DispatchRole;
+    producer: string;
+    provenance: IdentityProvenance;
+    modelAxis: string;
+    effortAxis: string;
+    dispatchPolicy: string;
+    dispatchCeiling: string;
+    target: string;
+}
+export interface DispatchStamp extends DispatchStampRecord {
+    line: string;
+    lineNumber: number;
+    legacy: boolean;
+}
+export interface ProducerIdentity {
+    scope: string;
+    action: DispatchAction;
+    role: DispatchRole;
+    producer: string;
+    provenance: IdentityProvenance;
+    target: string;
+}
+export interface ParseDispatchStampsOptions {
+    onWarning?: (warning: string) => void;
+}
+export declare function formatDispatchStamp(record: DispatchStampRecord): string;
+export declare function parseDispatchStamps(markdown: string, options?: ParseDispatchStampsOptions): DispatchStamp[];
+export declare function getProducerIdentitiesByScope(markdown: string, options?: ParseDispatchStampsOptions): Record<string, ProducerIdentity[]>;
+//# sourceMappingURL=stamp.d.ts.map