@cat-factory/kernel 0.271.0 → 0.273.0

package/dist/ports/notification-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notification-channel.d.ts","sourceRoot":"","sources":["../../src/ports/notification-channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE7F;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;CACrC;AAcD,MAAM,WAAW,mBAAmB;IAClC,mFAAmF;IACnF,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACxE;AAED,0FAA0F;AAC1F,qBAAa,4BAA6B,YAAW,mBAAmB;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAArC,YAA6B,QAAQ,EAAE,mBAAmB,EAAE,EAAI;IAE1D,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAU5E;CACF;AAED,2FAA2F;AAC3F,qBAAa,uBAAwB,YAAW,mBAAmB;IAC3D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAG;CAClC"}
+{"version":3,"file":"notification-channel.d.ts","sourceRoot":"","sources":["../../src/ports/notification-channel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,2BAA2B,EAC3B,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,gBAAgB,CAAA;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;CACrC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,6BAA6B,YAAI,QAAQ,EAAE,WAAW,EAAE,SAAS,CAAU,CAAA;AAExF,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,6BAA6B,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvF,kFAAkF;AAClF,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,0BAA0B,CAEhG;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAU9E;AAMD,MAAM,WAAW,mBAAmB;IAClC,2FAA2F;IAC3F,OAAO,CACL,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAAA;CACjB;AAED,0FAA0F;AAC1F,qBAAa,4BAA6B,YAAW,mBAAmB;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAArC,YAA6B,QAAQ,EAAE,mBAAmB,EAAE,EAAI;IAE1D,OAAO,CACX,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAUf;CACF;AAED,2FAA2F;AAC3F,qBAAa,uBAAwB,YAAW,mBAAmB;IAC3D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAG;CAClC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CACN,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,OAAO,CAAC,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,yBAA0B,YAAW,mBAAmB;IAEjE,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IAJ3B,YACmB,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,mBAAmB,EAC1B,OAAO,CAAC,GAAE,CACzB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAA;QACnB,cAAc,EAAE,MAAM,CAAA;QACtB,OAAO,EAAE,2BAA2B,CAAA;KACrC,KACE,IAAI,aAAA,EACP;IAEE,OAAO,CACX,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAGf;YAEa,MAAM;CAYrB"}

package/dist/ports/notification-channel.js

@@ -1,13 +1,78 @@
+import { defaultNotificationRoute } from '@cat-factory/contracts';
+// Port for *delivering* a notification to humans. The NotificationService owns
+// the canonical persistence + lifecycle (raise / list / resolve); a channel is
+// purely "how a human is told". This is the extension seam for future delivery
+// mechanisms: in-app (push the `notification` WorkspaceEvent to the board) is the
+// only channel today, but an EmailNotificationChannel / SlackNotificationChannel
+// implement the same port and are composed in via CompositeNotificationChannel —
+// no change to the call sites that raise notifications.
+//
+// All deliveries are best-effort: a channel failure must never break the state
+// transition that raised the notification (the row is already persisted). Channels
+// swallow their own errors, exactly like the event publisher.
+/**
+ * WHICH lifecycle edge a delivery reports. The NotificationService re-delivers a card on
+ * every transition it makes, and the transports split hard on what that means:
+ *
+ * - A STATE transport (the in-app push, the outbound webhook) carries the card's current
+ *   value, so it wants every edge: a board holding an open card has to see it settle, or
+ *   it renders an already-dismissed decision as still actionable until the next reload.
+ * - An ALERT transport (email, Slack) interrupts a human, so it wants the FIRST edge only.
+ *   Mailing a board "Decision needed: …" after the decision was made is not a stale render,
+ *   it is a wrong statement that cannot be taken back.
+ *
+ * Without this, a channel can only guess from `notification.status`, and the two edges that
+ * matter most are indistinguishable there: an escalation and a fresh raise are both `open`.
+ * It is a required parameter so a new call site fails to typecheck rather than silently
+ * picking whichever reading the channel it happens to reach assumes.
+ *
+ * The members, in lifecycle order:
+ * - `raised`: a human is being asked something they have NOT been asked. A new card, or one
+ *   whose user-visible content changed.
+ * - `refreshed`: the same open card moved without a new ask. The escalation sweep flipped it
+ *   red; a failed action put it back.
+ * - `settled`: the card is no longer actionable. Acted on, resolved, or auto-dismissed.
+ *
+ * Declared as a LIST rather than a bare union because one consumer has to check it at runtime:
+ * the mothership relay reads this off the wire from a node that may be a different build, and a
+ * predicate derived from the vocabulary's own members cannot fall out of step with it.
+ */
+export const NOTIFICATION_DELIVERY_REASONS = ['raised', 'refreshed', 'settled'];
+/** Whether an arbitrary value is one of {@link NOTIFICATION_DELIVERY_REASONS}. */
+export function isNotificationDeliveryReason(value) {
+    return NOTIFICATION_DELIVERY_REASONS.includes(value);
+}
+/**
+ * Whether this edge is a NEW ask, and so the one an alert transport delivers on.
+ *
+ * The single place that judgement lives: three transports would otherwise each restate it,
+ * and a fourth would arrive stating it slightly differently. Exhaustive over the union, so
+ * adding an edge fails the build here rather than defaulting to "interrupt everyone".
+ */
+export function isAlertingDelivery(reason) {
+    switch (reason) {
+        case 'raised':
+            return true;
+        case 'refreshed':
+        case 'settled':
+            return false;
+        default:
+            return assertNeverDeliveryReason(reason);
+    }
+}
+function assertNeverDeliveryReason(reason) {
+    throw new Error(`unhandled notification delivery reason: ${String(reason)}`);
+}
 /** Fan a notification out to every configured channel, isolating per-channel failures. */
 export class CompositeNotificationChannel {
     channels;
     constructor(channels) {
         this.channels = channels;
     }
-    async deliver(workspaceId, notification) {
+    async deliver(workspaceId, notification, reason) {
         await Promise.all(this.channels.map(async (channel) => {
             try {
-                await channel.deliver(workspaceId, notification);
+                await channel.deliver(workspaceId, notification, reason);
             }
             catch {
                 // Best-effort: one channel failing must not block the others or the caller.
@@ -19,4 +84,66 @@ export class CompositeNotificationChannel {
 export class NoopNotificationChannel {
     async deliver() { }
 }
+/**
+ * Gates one channel's deliveries on the workspace's routing for that channel.
+ *
+ * A DECORATOR rather than a filter inside {@link CompositeNotificationChannel}, because
+ * only some transports are routed here: Slack and the outbound webhooks answer "which
+ * types" where their destination is declared (a Slack route's channel, a webhook
+ * endpoint's own `types` filter), so wrapping them would be a second switch for a
+ * question already decided. A facade wraps exactly the channels the manager owns, and
+ * what it wrapped is legible at the wiring site.
+ *
+ * It gates the ALERTING edge ONLY (see {@link NotificationDeliveryReason}). Two things
+ * follow from that, and both are the point rather than a concession:
+ *
+ * - A mute stops the interruption, never a correction. The card is persisted whatever the
+ *   routing says and reaches every board on its next snapshot, so withholding the SETTLED
+ *   push would leave those boards rendering a decision that was already made as still
+ *   waiting for one, curable only by a reload.
+ * - The routing read happens on the raise and nowhere else. The escalation sweep re-delivers
+ *   every overdue card in a workspace in one loop; a gate that consulted the store per card
+ *   would be a read per card per channel, and one mothership round trip each.
+ *
+ * What remains is one read per raised card per routed channel. That is deliberate rather
+ * than un-batched: the two routed channels land in DIFFERENT channel sets (the in-app push is
+ * local, email is external and mothership-delivered), so there is no single point that could
+ * ask once for both, and a raise is a human-scale event.
+ *
+ * A router failure means the decision is UNKNOWN, and the honest reading of that is the
+ * SHIPPED DEFAULT rather than silence: a settings read failing must not be the reason a
+ * human never hears that their run parked, and it must not turn every muted type into a
+ * mailshot either. So a throw falls back to the same default a workspace that never
+ * configured anything gets, and is reported through `onError` instead of swallowed.
+ */
+export class RoutedNotificationChannel {
+    channel;
+    router;
+    inner;
+    onError;
+    constructor(channel, router, inner, onError) {
+        this.channel = channel;
+        this.router = router;
+        this.inner = inner;
+        this.onError = onError;
+    }
+    async deliver(workspaceId, notification, reason) {
+        if (isAlertingDelivery(reason) && !(await this.routes(workspaceId, notification)))
+            return;
+        await this.inner.deliver(workspaceId, notification, reason);
+    }
+    async routes(workspaceId, notification) {
+        try {
+            return await this.router.isRouted(workspaceId, notification.type, this.channel);
+        }
+        catch (error) {
+            this.onError?.(error, {
+                workspaceId,
+                notificationId: notification.id,
+                channel: this.channel,
+            });
+            return defaultNotificationRoute(notification.type, this.channel);
+        }
+    }
+}
 //# sourceMappingURL=notification-channel.js.map

package/dist/ports/notification-channel.js.map

@@ -1 +1 @@
-{"version":3,"file":"notification-channel.js","sourceRoot":"","sources":["../../src/ports/notification-channel.ts"],"names":[],"mappings":"AAmCA,0FAA0F;AAC1F,MAAM,OAAO,4BAA4B;IACV,QAAQ;IAArC,YAA6B,QAA+B;wBAA/B,QAAQ;IAA0B,CAAC;IAEhE,KAAK,CAAC,OAAO,CAAC,WAAmB,EAAE,YAA0B;QAC3D,MAAM,OAAO,CAAC,GAAG,CACf,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YAClC,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,YAAY,CAAC,CAAA;YAClD,CAAC;YAAC,MAAM,CAAC;gBACP,4EAA4E;YAC9E,CAAC;QACH,CAAC,CAAC,CACH,CAAA;IACH,CAAC;CACF;AAED,2FAA2F;AAC3F,MAAM,OAAO,uBAAuB;IAClC,KAAK,CAAC,OAAO,KAAmB,CAAC;CAClC"}
+{"version":3,"file":"notification-channel.js","sourceRoot":"","sources":["../../src/ports/notification-channel.ts"],"names":[],"mappings":"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"}

package/dist/ports/notification-settings-repositories.d.ts

@@ -0,0 +1,16 @@
+import type { NotificationRoutingMatrix } from '../domain/types.js';
+export interface NotificationSettingsRecord {
+    workspaceId: string;
+    /** The {@link NotificationRoutingMatrix}, serialized as JSON. */
+    matrixJson: string;
+    updatedAt: number;
+}
+export interface NotificationSettingsRepository {
+    /** A workspace's routing overrides, or null when it has never configured any. */
+    getByWorkspace(workspaceId: string): Promise<NotificationSettingsRecord | null>;
+    /** Create or replace a workspace's routing overrides. */
+    upsert(record: NotificationSettingsRecord): Promise<void>;
+}
+/** Re-exported for repository implementations that map the persisted matrix. */
+export type { NotificationRoutingMatrix };
+//# sourceMappingURL=notification-settings-repositories.d.ts.map

package/dist/ports/notification-settings-repositories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-settings-repositories.d.ts","sourceRoot":"","sources":["../../src/ports/notification-settings-repositories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AAYnE,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,MAAM,CAAA;IACnB,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,8BAA8B;IAC7C,iFAAiF;IACjF,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC,CAAA;IAC/E,yDAAyD;IACzD,MAAM,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1D;AAED,gFAAgF;AAChF,YAAY,EAAE,yBAAyB,EAAE,CAAA"}

package/dist/ports/notification-settings-repositories.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=notification-settings-repositories.js.map

package/dist/ports/notification-settings-repositories.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-settings-repositories.js","sourceRoot":"","sources":["../../src/ports/notification-settings-repositories.ts"],"names":[],"mappings":""}

package/dist/shared/post-mortem.logic.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The cap on a composed post-mortem, matching the debug API's own `MAX_EVICTION_DETAIL_CHARS`
+ * read budget: past it the text is not merely long, it is text no reader can be served in one
+ * response anyway.
+ */
+export declare const MAX_POST_MORTEM_CHARS = 4000;
+/**
+ * Join a post-mortem's parts into the scrubbed, bounded `detail` a transport reports beside an
+ * eviction. Empty/blank parts are dropped, so a caller composes with plain optionals rather than
+ * building an array conditionally; everything empty ⇒ `undefined`, which is the honest answer
+ * ("nothing could be read") and the one the eviction view omits the field for.
+ *
+ * ORDER MATTERS: the cap keeps the HEAD, so the caller's own one-line verdict ("the container
+ * exited with code 137") must come first and any bulk material (a log tail, a kubelet message)
+ * after it. A caller passing bulk is expected to have bounded it already, with
+ * {@link tailPostMortemMaterial}: this cap is the backstop, not the sizing decision, and it says
+ * what it dropped rather than ending mid-word and reading like the whole of what was there.
+ */
+export declare function composePostMortem(parts: Array<string | undefined>): string | undefined;
+/**
+ * Bound BULK post-mortem material (a container's captured output, a harness's stderr) to its
+ * LAST `maxChars` characters, saying what it dropped.
+ *
+ * The TAIL, and that direction is the whole reason this exists beside {@link composePostMortem}.
+ * The compose cap keeps the head because what it bounds is a composed detail whose one-line
+ * verdict comes first; a log is the opposite shape, and its value is at the end, where the crash
+ * is. Let bulk reach the compose cap unbounded and the two rules combine into the worst possible
+ * one: the boot chatter is kept and the death is dropped.
+ *
+ * A LINE bound (`docker logs --tail 50`, a stderr ring) is not this bound. Fifty lines of an
+ * agent echoing a base64 payload is not a short tail, and a producer that only counts lines has
+ * no idea how many characters it just handed over.
+ */
+export declare function tailPostMortemMaterial(text: string, maxChars: number): string;
+//# sourceMappingURL=post-mortem.logic.d.ts.map

package/dist/shared/post-mortem.logic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-mortem.logic.d.ts","sourceRoot":"","sources":["../../src/shared/post-mortem.logic.ts"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,OAAQ,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAYtF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI7E"}

package/dist/shared/post-mortem.logic.js

@@ -0,0 +1,72 @@
+import { redactSecrets } from './redact-secrets.logic.js';
+// Composing the one thing a dead container leaves behind.
+//
+// A transport that discovers its backend is gone gets exactly one chance to say WHY: the
+// `RunnerJobView.detail` it mints beside the eviction, which the engine persists as the step's
+// `firstEvictionDetail` and renders on the run. Every producer of that text has the same two
+// obligations, and each was being restated per transport:
+//
+//   - **Scrub it.** The material is a container's own output, a kubelet message, a harness's
+//     stderr: free text that routinely echoes a token it was handed. It is persisted and
+//     rendered to a person, so it goes through `redactSecrets` before either happens.
+//   - **Bound it.** A post-mortem is a diagnostic, not a log sink, and it rides a row every
+//     read of the run pays for.
+//
+// Both live here so a new transport inherits them by calling this rather than by someone
+// remembering. Sibling of `describeProcessExit`, which owns the other half of the same job:
+// how the death is WORDED.
+/**
+ * The cap on a composed post-mortem, matching the debug API's own `MAX_EVICTION_DETAIL_CHARS`
+ * read budget: past it the text is not merely long, it is text no reader can be served in one
+ * response anyway.
+ */
+export const MAX_POST_MORTEM_CHARS = 4_000;
+/**
+ * Join a post-mortem's parts into the scrubbed, bounded `detail` a transport reports beside an
+ * eviction. Empty/blank parts are dropped, so a caller composes with plain optionals rather than
+ * building an array conditionally; everything empty ⇒ `undefined`, which is the honest answer
+ * ("nothing could be read") and the one the eviction view omits the field for.
+ *
+ * ORDER MATTERS: the cap keeps the HEAD, so the caller's own one-line verdict ("the container
+ * exited with code 137") must come first and any bulk material (a log tail, a kubelet message)
+ * after it. A caller passing bulk is expected to have bounded it already, with
+ * {@link tailPostMortemMaterial}: this cap is the backstop, not the sizing decision, and it says
+ * what it dropped rather than ending mid-word and reading like the whole of what was there.
+ */
+export function composePostMortem(parts) {
+    const joined = parts
+        .map((part) => part?.trim())
+        .filter((part) => !!part)
+        .join('\n');
+    if (!joined)
+        return undefined;
+    // Scrub BEFORE the cap, so the two can't disagree about where a redacted span started.
+    const scrubbed = redactSecrets(joined);
+    if (!scrubbed)
+        return undefined;
+    if (scrubbed.length <= MAX_POST_MORTEM_CHARS)
+        return scrubbed;
+    const dropped = scrubbed.length - MAX_POST_MORTEM_CHARS;
+    return `${scrubbed.slice(0, MAX_POST_MORTEM_CHARS)}\n…(${dropped} more characters of post-mortem detail dropped)`;
+}
+/**
+ * Bound BULK post-mortem material (a container's captured output, a harness's stderr) to its
+ * LAST `maxChars` characters, saying what it dropped.
+ *
+ * The TAIL, and that direction is the whole reason this exists beside {@link composePostMortem}.
+ * The compose cap keeps the head because what it bounds is a composed detail whose one-line
+ * verdict comes first; a log is the opposite shape, and its value is at the end, where the crash
+ * is. Let bulk reach the compose cap unbounded and the two rules combine into the worst possible
+ * one: the boot chatter is kept and the death is dropped.
+ *
+ * A LINE bound (`docker logs --tail 50`, a stderr ring) is not this bound. Fifty lines of an
+ * agent echoing a base64 payload is not a short tail, and a producer that only counts lines has
+ * no idea how many characters it just handed over.
+ */
+export function tailPostMortemMaterial(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const dropped = text.length - maxChars;
+    return `…(${dropped} earlier characters dropped)\n${text.slice(-maxChars)}`;
+}
+//# sourceMappingURL=post-mortem.logic.js.map

package/dist/shared/post-mortem.logic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-mortem.logic.js","sourceRoot":"","sources":["../../src/shared/post-mortem.logic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAEzD,0DAA0D;AAC1D,EAAE;AACF,yFAAyF;AACzF,+FAA+F;AAC/F,6FAA6F;AAC7F,0DAA0D;AAC1D,EAAE;AACF,6FAA6F;AAC7F,yFAAyF;AACzF,sFAAsF;AACtF,4FAA4F;AAC5F,gCAAgC;AAChC,EAAE;AACF,yFAAyF;AACzF,4FAA4F;AAC5F,2BAA2B;AAE3B;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAgC;IAChE,MAAM,MAAM,GAAG,KAAK;SACjB,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;SAC3B,MAAM,CAAC,CAAC,IAAI,EAAkB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;SACxC,IAAI,CAAC,IAAI,CAAC,CAAA;IACb,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAA;IAC7B,uFAAuF;IACvF,MAAM,QAAQ,GAAG,aAAa,CAAC,MAAM,CAAC,CAAA;IACtC,IAAI,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAA;IAC/B,IAAI,QAAQ,CAAC,MAAM,IAAI,qBAAqB;QAAE,OAAO,QAAQ,CAAA;IAC7D,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,qBAAqB,CAAA;IACvD,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,OAAO,OAAO,iDAAiD,CAAA;AACnH,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAY,EAAE,QAAgB;IACnE,IAAI,IAAI,CAAC,MAAM,IAAI,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAA;IACtC,OAAO,KAAK,OAAO,iCAAiC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAA;AAC7E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/kernel",
-  "version": "0.271.0",
+  "version": "0.273.0",
   "description": "Shared vocabulary, pure logic, and port interfaces for the Agent Architecture Board.",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
   "dependencies": {
     "ai": "^7.0.51",
     "yaml": "^2.9.0",
-    "@cat-factory/contracts": "0.273.0"
+    "@cat-factory/contracts": "0.275.0"
   },
   "devDependencies": {
     "@stryker-mutator/core": "9.6.1",