@open-agent-toolkit/cli 0.3.7 → 0.3.9

package/dist/providers/identity/generic-dispatch-record.d.ts

@@ -1,9 +1,204 @@
 import { z } from 'zod';
+import { type DispatchValueViolation } from './absolute-paths.js';
 /**
  * Whole-record ceiling, applied at every parse entry point so no combination
  * of individually legal fields can produce an unbounded journal revision.
  */
 export declare function assertBoundedDispatchRecordSize(value: unknown): void;
+/**
+ * The closed field set before cross-field refinement. Exported so a caller
+ * that validates a partial record — the managed Claude `recordBase`, whose
+ * derived fields are omitted — can report every missing, mistyped, or unknown
+ * field in one pass instead of discovering them one run at a time.
+ */
+export declare const genericDispatchRecordBaseSchema: z.ZodObject<{
+    request_id: z.ZodString;
+    caller: z.ZodString;
+    scope: z.ZodString;
+    objective: z.ZodString;
+    action: z.ZodString;
+    role_name: z.ZodString;
+    role_class: z.ZodString;
+    provider: z.ZodString;
+    dispatch_context: z.ZodString;
+    dispatch_policy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    dispatch_ceiling: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    catalog_snapshot: z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        observed_at: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        source: string;
+        observed_at: string;
+    }, {
+        id: string;
+        source: string;
+        observed_at: string;
+    }>;
+    authority: z.ZodString;
+    role_selector: z.ZodNullable<z.ZodString>;
+    model_selector: z.ZodNullable<z.ZodString>;
+    model_selector_granularity: z.ZodNullable<z.ZodString>;
+    effort_selector: z.ZodNullable<z.ZodString>;
+    reasoning_mode_selector: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    service_tier_selector: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    guidance_reference: z.ZodOptional<z.ZodString>;
+    guidance_version: z.ZodOptional<z.ZodString>;
+    guidance_verified_at: z.ZodOptional<z.ZodString>;
+    guidance_status: z.ZodOptional<z.ZodEnum<["fresh", "review-required", "stale"]>>;
+    selection_source: z.ZodEnum<["native-default", "policy-resolved", "explicit-user"]>;
+    candidates_considered: z.ZodArray<z.ZodString, "many">;
+    selection_reason: z.ZodEnum<["native-catalog", "native-catalog-unsatisfying", "pre-start-rejection", "inherit", "gate-target"]>;
+    selected_route: z.ZodString;
+    deadline_seconds: z.ZodNumber;
+    retry_limit: z.ZodNumber;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    launch_status: z.ZodEnum<["planned", "accepted", "blocked-before-start"]>;
+    child_outcome: z.ZodNullable<z.ZodString>;
+    configured_invocation_evidence: z.ZodArray<z.ZodUnknown, "many">;
+    runtime_confirmation: z.ZodString;
+    diagnostics: z.ZodArray<z.ZodString, "many">;
+    continuation_events: z.ZodArray<z.ZodUnknown, "many">;
+    fallback: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        allow_below_task_class_floor: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    }, {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    }>>;
+    task_class: z.ZodOptional<z.ZodEnum<["mechanical-recon", "intelligent-recon", "default-implementation", "hard-reasoning", "consequential"]>>;
+    model_class_floor: z.ZodOptional<z.ZodString>;
+    classification_source: z.ZodOptional<z.ZodLiteral<"caller">>;
+    classification_reason: z.ZodOptional<z.ZodString>;
+    floor_satisfaction: z.ZodOptional<z.ZodEnum<["satisfied", "unsatisfied"]>>;
+    authorization_scope: z.ZodOptional<z.ZodString>;
+    expected_output: z.ZodOptional<z.ZodString>;
+    verification_evidence: z.ZodOptional<z.ZodString>;
+    escalate_when: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+}, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+}>;
+/**
+ * Cross-field rules over the base object. Every field is read defensively, so
+ * the same rules apply to a partial projection of the record (for example one
+ * with the managed Claude derived fields omitted).
+ */
+export declare function refineGenericDispatchRecord(record: Partial<z.infer<typeof genericDispatchRecordBaseSchema>>, context: z.RefinementCtx): void;
 export declare const genericDispatchRecordSchema: z.ZodEffects<z.ZodObject<{
     request_id: z.ZodString;
     caller: z.ZodString;
@@ -298,7 +493,24 @@ export declare const genericDispatchRecordSchema: z.ZodEffects<z.ZodObject<{
 }>;
 export type GenericDispatchRecord = z.infer<typeof genericDispatchRecordSchema>;
 export declare function normalizeDispatchKey(key: string): string;
+/** The stable stand-in for a scrubbed secret-shaped value. */
+export declare const REDACTED_SECRET = "<redacted-secret>";
+/**
+ * Scrub every secret-shaped value from outgoing text, using the same value
+ * detector the sensitive-content walk uses. Each match is extended to the end
+ * of its token, so a pattern that recognizes only a prefix (a JWT's header and
+ * payload, say) does not leave the rest behind. Like the detector, this is a
+ * best-effort layer: a value that no pattern recognizes survives.
+ */
+export declare function redactSensitiveValues(text: string): string;
 export declare function isSensitiveDispatchKey(key: string): boolean;
+/**
+ * Collect every sensitive key and value, in the same depth-first order
+ * {@link assertNoSensitiveDispatchContent} visits them. A sensitive key is
+ * reported once and not descended into: everything beneath it is already
+ * forbidden, and its content must not be echoed back in a report.
+ */
+export declare function collectSensitiveDispatchContent(value: unknown, path?: string): DispatchValueViolation[];
 export declare function assertNoSensitiveDispatchContent(value: unknown, path?: string): void;
 /**
  * The persistence-boundary path sanitizer for the generic record.

package/dist/providers/identity/generic-dispatch-record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generic-dispatch-record.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/generic-dispatch-record.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4KxB;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAOpE;AAUD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6HpC,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAwFhF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD;AAuGD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAS3D;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,IAAI,SAAa,GAChB,IAAI,CAwBN;AAyBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,qBAAqB,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,qBAAqB,GAC5B,qBAAqB,CAYvB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,qBAAqB,CAavB"}
+{"version":3,"file":"generic-dispatch-record.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/generic-dispatch-record.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,kBAAkB,CAAC;AAuK1B;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAOpE;AAUD;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmEjC,CAAC;AAEZ;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC,EAChE,OAAO,EAAE,CAAC,CAAC,aAAa,GACvB,IAAI,CAyDN;AAED,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACkC,CAAC;AAE3E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAwFhF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD;AAuGD,8DAA8D;AAC9D,eAAO,MAAM,eAAe,sBAAsB,CAAC;AAanD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAc1D;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAS3D;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,EACd,IAAI,SAAa,GAChB,sBAAsB,EAAE,CA6B1B;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,IAAI,SAAa,GAChB,IAAI,CAGN;AAyBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,qBAAqB,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,qBAAqB,GAC5B,qBAAqB,CAYvB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,qBAAqB,CAavB"}

package/dist/providers/identity/generic-dispatch-record.js

@@ -15,7 +15,7 @@ const reasonText = () => z.string().min(1).max(MAX_REASON_LENGTH);
 const proseText = () => z.string().min(1).max(MAX_PROSE_LENGTH);
 const requestIdSchema = z
     .string()
-    .regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/, 'request_id must be a stable contained identifier');
+    .regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/, 'request_id must be a stable contained identifier: expected [a-zA-Z0-9] followed by up to 127 of [a-zA-Z0-9._-]');
 const catalogSnapshotSchema = z
     .object({
     id: identifier(),
@@ -149,7 +149,13 @@ const TASK_CLASS_FIELDS = [
     'classification_reason',
     'floor_satisfaction',
 ];
-export const genericDispatchRecordSchema = z
+/**
+ * The closed field set before cross-field refinement. Exported so a caller
+ * that validates a partial record — the managed Claude `recordBase`, whose
+ * derived fields are omitted — can report every missing, mistyped, or unknown
+ * field in one pass instead of discovering them one run at a time.
+ */
+export const genericDispatchRecordBaseSchema = z
     .object({
     request_id: requestIdSchema,
     caller: identifier(),
@@ -216,8 +222,13 @@ export const genericDispatchRecordSchema = z
     verification_evidence: proseText().optional(),
     escalate_when: z.array(reasonText()).optional(),
 })
-    .strict()
-    .superRefine((record, context) => {
+    .strict();
+/**
+ * Cross-field rules over the base object. Every field is read defensively, so
+ * the same rules apply to a partial projection of the record (for example one
+ * with the managed Claude derived fields omitted).
+ */
+export function refineGenericDispatchRecord(record, context) {
     if (record.launch_status === 'accepted' && record.child_outcome === null) {
         context.addIssue({
             code: z.ZodIssueCode.custom,
@@ -264,7 +275,8 @@ export const genericDispatchRecordSchema = z
             path: ['model_class_floor'],
         });
     }
-});
+}
+export const genericDispatchRecordSchema = genericDispatchRecordBaseSchema.superRefine(refineGenericDispatchRecord);
 /**
  * Latin look-alikes from other scripts, folded to their Latin counterpart so a
  * homoglyph spelling classifies as the token it imitates. This map is a
@@ -444,6 +456,37 @@ const SENSITIVE_VALUE_PATTERNS = [
     /\bnpm_[A-Za-z0-9]{30,}/,
     /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/?#@]+:[^\s:/?#@]+@/i,
 ];
+/** The stable stand-in for a scrubbed secret-shaped value. */
+export const REDACTED_SECRET = '<redacted-secret>';
+/**
+ * A private key block is multi-line, so the header pattern alone would leave
+ * its body behind; the whole block is replaced first. An unterminated block
+ * runs to the end of the text, which fails safe (no body line survives) but
+ * also consumes everything after it. Callers joining several messages should
+ * therefore scrub each message before joining, as the managed Claude report
+ * does, and keep this pass as the backstop.
+ */
+const PRIVATE_KEY_BLOCK = /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----[\s\S]*?(?:-----END (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----|$)/gi;
+/**
+ * Scrub every secret-shaped value from outgoing text, using the same value
+ * detector the sensitive-content walk uses. Each match is extended to the end
+ * of its token, so a pattern that recognizes only a prefix (a JWT's header and
+ * payload, say) does not leave the rest behind. Like the detector, this is a
+ * best-effort layer: a value that no pattern recognizes survives.
+ */
+export function redactSensitiveValues(text) {
+    let redacted = text.replace(PRIVATE_KEY_BLOCK, REDACTED_SECRET);
+    for (const pattern of SENSITIVE_VALUE_PATTERNS) {
+        const flags = pattern.flags.includes('g')
+            ? pattern.flags
+            : `${pattern.flags}g`;
+        redacted = redacted.replace(new RegExp(`(?:${pattern.source})[^\\s'"\`,;)\\]}]*`, flags), 
+        // Extending to the token end also takes a sentence's closing period;
+        // give it back so the scrubbed message still reads as a sentence.
+        (match) => `${REDACTED_SECRET}${/\.+$/.exec(match)?.[0] ?? ''}`);
+    }
+    return redacted;
+}
 export function isSensitiveDispatchKey(key) {
     const { normalized, unrecognized } = foldDispatchKey(key);
     // Fail closed: a key this normalizer cannot fully account for is treated as
@@ -458,26 +501,42 @@ export function isSensitiveDispatchKey(key) {
         return true;
     return SENSITIVE_KEY_FAMILIES.some((family) => normalized.includes(family));
 }
-export function assertNoSensitiveDispatchContent(value, path = '<record>') {
+/**
+ * Collect every sensitive key and value, in the same depth-first order
+ * {@link assertNoSensitiveDispatchContent} visits them. A sensitive key is
+ * reported once and not descended into: everything beneath it is already
+ * forbidden, and its content must not be echoed back in a report.
+ */
+export function collectSensitiveDispatchContent(value, path = '<record>') {
     if (typeof value === 'string') {
-        if (SENSITIVE_VALUE_PATTERNS.some((pattern) => pattern.test(value))) {
-            throw new Error(`Sensitive dispatch content is forbidden at ${path}.`);
-        }
-        return;
+        return SENSITIVE_VALUE_PATTERNS.some((pattern) => pattern.test(value))
+            ? [
+                {
+                    path,
+                    message: `Sensitive dispatch content is forbidden at ${path}.`,
+                },
+            ]
+            : [];
     }
     if (Array.isArray(value)) {
-        value.forEach((entry, index) => assertNoSensitiveDispatchContent(entry, `${path}[${index}]`));
-        return;
+        return value.flatMap((entry, index) => collectSensitiveDispatchContent(entry, `${path}[${index}]`));
     }
     if (value === null || typeof value !== 'object') {
-        return;
-    }
-    for (const [key, entry] of Object.entries(value)) {
-        if (isSensitiveDispatchKey(key)) {
-            throw new Error(`Sensitive dispatch content is forbidden at ${path}.${key}.`);
-        }
-        assertNoSensitiveDispatchContent(entry, `${path}.${key}`);
+        return [];
     }
+    return Object.entries(value).flatMap(([key, entry]) => isSensitiveDispatchKey(key)
+        ? [
+            {
+                path: `${path}.${key}`,
+                message: `Sensitive dispatch content is forbidden at ${path}.${key}.`,
+            },
+        ]
+        : collectSensitiveDispatchContent(entry, `${path}.${key}`));
+}
+export function assertNoSensitiveDispatchContent(value, path = '<record>') {
+    const [first] = collectSensitiveDispatchContent(value, path);
+    if (first)
+        throw new Error(first.message);
 }
 /**
  * Fields where an absolute path is incidental content rather than a malformed

package/dist/providers/identity/oat-dispatch-record.d.ts

@@ -1953,6 +1953,11 @@ declare const oatDispatchEvidenceEventSchema: z.ZodDiscriminatedUnion<"kind", [z
     };
 }>]>;
 export type OatDispatchEvidenceEvent = z.infer<typeof oatDispatchEvidenceEventSchema>;
+/**
+ * Non-throwing event validation, so a caller can report every event issue
+ * alongside violations found in other stages of the same input.
+ */
+export declare function safeParseOatDispatchEvidenceEvent(value: unknown): z.SafeParseReturnType<unknown, OatDispatchEvidenceEvent>;
 export declare function parsePersistedOatDispatchRecord(value: unknown): PersistedOatDispatchRecordV1;
 export declare function augmentDispatchRecord(input: {
     record: GenericDispatchRecord | PersistedOatDispatchRecordV1;

package/dist/providers/identity/oat-dispatch-record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oat-dispatch-record.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/oat-dispatch-record.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"oat-dispatch-record.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/oat-dispatch-record.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,YAC/C,yBAAyB,EACzB,2BAA2B,EAC3B,6BAA6B,EAC7B,6BAA6B,EAC7B,sCAAsC,EACtC,0BAA0B,EAC1B,wBAAwB,CAChB,CAAC;AAEX,MAAM,MAAM,+BAA+B,GACzC,CAAC,OAAO,oCAAoC,CAAC,CAAC,MAAM,CAAC,CAAC;AA0DxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,iCAAiC,omBAgCe,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,+BAA+B,wRAgBiB,CAAC;AAE9D,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAe5D;AAaD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CAI7E;AAyED,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EASZ,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAkB/D,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQlB,CAAC;AA2BH;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAOnE;AAYD,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;IAcxB;;;;;;OAMG;;;;;;;;;;;;;;;;;;;;;;;;;;IAOP,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,yBAAyB,GACjC,MAAM,GACN,SAAS,MAAM,EAAE,GACjB,IAAI,GACJ,SAAS,CAAC;AAEd,MAAM,WAAW,kCAAkC;IACjD,IAAI,CAAC,EAAE,yBAAyB,CAAC;IACjC,KAAK,CAAC,EAAE,yBAAyB,CAAC;IAClC,MAAM,CAAC,EAAE,yBAAyB,CAAC;IACnC,WAAW,CAAC,EAAE,yBAAyB,CAAC;CACzC;AAED,iFAAiF;AACjF,eAAO,MAAM,6BAA6B,gBAAgB,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,qBAAqB,GAC5B,kCAAkC,CAUpC;AAED,MAAM,MAAM,uBAAuB,GAC/B,UAAU,GACV,aAAa,GACb,gBAAgB,CAAC;AA6BrB;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,uBAAuB,EACjC,UAAU,EAAE,kCAAkC,GAAG,IAAI,GAAG,SAAS,GAChE,MAAM,EAAE,CAMV;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,uBAAuB,EACjC,UAAU,EAAE,kCAAkC,GAAG,IAAI,GAAG,SAAS,GAChE,uBAAuB,CASzB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACzC,UAAU,CAAC,EAAE,kCAAkC,GAAG,IAAI,CAAC;CACxD,GAAG,kBAAkB,CAwBrB;AAED;;;;GAIG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;EAKd,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAahE,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA9MvC;;;;;;eAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2ME,CAAC;AAEZ;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,kBAAkB,CAE1E;AAED,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,gCAAgC,CACxC,CAAC;AAEF,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAlO9B;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsQP,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,GACb,CAAC,CAAC,mBAAmB,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAE1D;AAgDD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,GACb,4BAA4B,CAiB9B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,MAAM,EAAE,qBAAqB,GAAG,4BAA4B,CAAC;IAC7D,KAAK,EAAE,wBAAwB,CAAC;IAChC,aAAa,CAAC,EAAE,4BAA4B,CAAC;IAC7C,cAAc,CAAC,EAAE,SAAS,4BAA4B,EAAE,CAAC;CAC1D,GAAG,4BAA4B,CA2K/B"}

package/dist/providers/identity/oat-dispatch-record.js

@@ -194,7 +194,7 @@ function differingControlFields(left, right) {
 }
 const redactedPathSchema = z
     .string()
-    .regex(/^<(?:loaded|user|project)>\/agents\/[a-z0-9][a-z0-9_-]*\.md$/);
+    .regex(/^<(?:loaded|user|project)>\/agents\/[a-z0-9][a-z0-9_-]*\.md$/, 'expected <loaded|user|project>/agents/<name>.md');
 const candidateMissSchema = z
     .object({
     tier: z.enum(['loaded', 'user', 'project']),
@@ -219,7 +219,9 @@ const resolvedRoleSchema = z
     canonicalPath: redactedPathSchema,
     selectedPath: redactedPathSchema,
     roleVersion: z.string().min(1),
-    contentDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    contentDigest: z
+        .string()
+        .regex(/^sha256:[a-f0-9]{64}$/, 'expected sha256:<64 lowercase hex>'),
     candidateMisses: z.array(candidateMissSchema),
 })
     .strict();
@@ -522,6 +524,13 @@ const oatDispatchEvidenceEventSchema = z.discriminatedUnion('kind', [
     })
         .strict(),
 ]);
+/**
+ * Non-throwing event validation, so a caller can report every event issue
+ * alongside violations found in other stages of the same input.
+ */
+export function safeParseOatDispatchEvidenceEvent(value) {
+    return oatDispatchEvidenceEventSchema.safeParse(value);
+}
 function initialOatRecord() {
     return {
         schemaVersion: 1,

package/dist/providers/shared/registry.d.ts

@@ -52,6 +52,12 @@ export interface ProviderScopeContext {
     registrations: readonly ProviderRegistration[];
 }
 export declare function resolveCatalogRefreshPolicy(supported: boolean, providerPolicy?: ProviderCatalogRefreshPolicy): ProviderCatalogRefreshPolicy;
+/**
+ * Validates an untrusted catalog-refresh policy (for example one read back
+ * from a sync JSON payload) with the same provenance rules the registry
+ * applies to its own policies.
+ */
+export declare function isValidCatalogRefreshPolicy(value: unknown): value is ProviderCatalogRefreshPolicy;
 export type UserAgentMaterializationCoverage = 'none' | 'bundled' | 'all';
 export declare function userAgentMaterializationCoverage(input: {
     registrations: readonly ProviderRegistration[];

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

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

package/dist/providers/shared/registry.js

@@ -60,6 +60,36 @@ function hasValidRefreshProvenance(policy) {
     return (!Number.isNaN(date.getTime()) &&
         date.toISOString().slice(0, 10) === provenance.verifiedAt);
 }
+const CATALOG_REFRESH_STATES = new Set([
+    'live',
+    'manual-refresh',
+    'restart-required',
+    'unknown',
+]);
+/**
+ * Validates an untrusted catalog-refresh policy (for example one read back
+ * from a sync JSON payload) with the same provenance rules the registry
+ * applies to its own policies.
+ */
+export function isValidCatalogRefreshPolicy(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    if (typeof candidate.state !== 'string' ||
+        !CATALOG_REFRESH_STATES.has(candidate.state)) {
+        return false;
+    }
+    if (candidate.state === 'unknown') {
+        return typeof candidate.reason === 'string';
+    }
+    if (typeof candidate.provenance !== 'object' ||
+        candidate.provenance === null ||
+        Array.isArray(candidate.provenance)) {
+        return false;
+    }
+    return hasValidRefreshProvenance(value);
+}
 export function userAgentMaterializationCoverage(input) {
     const active = new Set(input.activeProviders);
     let coverage = 'none';

package/dist/rules/canonical/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/rules/canonical/parse.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,qBAAqB,EAGtB,MAAM,SAAS,CAAC;AAwFjB,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAa,GACpB;IACD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC;CACd,CAiBA;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAa,GACpB,qBAAqB,CAqCvB;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAGhC"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/rules/canonical/parse.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,qBAAqB,EAGtB,MAAM,SAAS,CAAC;AAoIjB,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAa,GACpB;IACD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC;CACd,CAiBA;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAa,GACpB,qBAAqB,CAyCvB;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAGhC"}

package/dist/rules/canonical/parse.js

@@ -51,6 +51,39 @@ function parseActivation(value, filePath) {
     }
     throw new CliError(`Frontmatter field "activation" in ${filePath} must be one of ${RULE_ACTIVATIONS.join(', ')}.`);
 }
+function isEmptyCursorGlobs(value) {
+    return (value === undefined ||
+        value === null ||
+        (typeof value === 'string' && value.trim() === '') ||
+        (Array.isArray(value) && value.length === 0));
+}
+/**
+ * Resolves the rule activation. An explicit `activation` always wins. Without
+ * one, a Cursor-style `alwaysApply: true` (written by third-party installers
+ * such as `argent init`, GitHub issue #316) is accepted as an alias for
+ * `activation: always`. Canonical rules keep globs only for
+ * `activation: glob`, so under the alias a null or empty Cursor-style `globs`
+ * is ignored and a non-empty one is rejected. Any other `alwaysApply` value
+ * without `activation` stays an activation error.
+ */
+function resolveActivation(frontmatter, filePath) {
+    if (frontmatter.activation !== undefined) {
+        return {
+            activation: parseActivation(frontmatter.activation, filePath),
+            ignoreGlobs: false,
+        };
+    }
+    if (frontmatter.alwaysApply === true) {
+        if (!isEmptyCursorGlobs(frontmatter.globs)) {
+            throw new CliError(`Frontmatter field "globs" in ${filePath} is not valid with "alwaysApply: true"; canonical rules keep globs only when activation is glob.`);
+        }
+        return { activation: 'always', ignoreGlobs: true };
+    }
+    return {
+        activation: parseActivation(frontmatter.activation, filePath),
+        ignoreGlobs: false,
+    };
+}
 export function stripTrailingOatMarker(content) {
     return content.replace(OAT_MARKER_PATTERN, '').trimEnd();
 }
@@ -72,11 +105,13 @@ export function parseMarkdownFrontmatter(markdown, filePath = '<inline>') {
 export function parseCanonicalRuleMarkdown(markdown, filePath = '<inline>') {
     const { frontmatter, body } = parseMarkdownFrontmatter(markdown, filePath);
     if (!frontmatter) {
-        throw new CliError('Rule markdown must include YAML frontmatter.');
+        throw new CliError(`Rule markdown in ${filePath} must include YAML frontmatter.`);
     }
-    const activation = parseActivation(frontmatter.activation, filePath);
+    const { activation, ignoreGlobs } = resolveActivation(frontmatter, filePath);
     const description = parseDescription(frontmatter.description, filePath);
-    const globs = parseGlobs(frontmatter.globs, filePath);
+    const globs = ignoreGlobs
+        ? undefined
+        : parseGlobs(frontmatter.globs, filePath);
     if (activation === 'glob' && (!globs || globs.length === 0)) {
         throw new CliError(`Frontmatter field "globs" is required in ${filePath} when activation is glob.`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-agent-toolkit/cli",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "private": false,
   "description": "Open Agent Toolkit CLI",
   "homepage": "https://github.com/voxmedia/open-agent-toolkit/tree/main/packages/cli",
@@ -34,7 +34,7 @@
     "ora": "^9.0.0",
     "yaml": "2.8.2",
     "zod": "^3.25.76",
-    "@open-agent-toolkit/control-plane": "0.3.7"
+    "@open-agent-toolkit/control-plane": "0.3.9"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",