@yaklabs-ai/plugin-sdk 0.13.10 → 0.14.0

package/dist/kay-app.d.ts

@@ -692,7 +692,7 @@ export declare type CorpusResourceKind = z.infer<typeof CorpusResourceKind>;
 declare function Create(hidden: ObjectLike_2, enumerable: ObjectLike_2, options?: ObjectLike_2): ObjectLike_2;
 
 /**
- * The `signals` a host with no Jev lane or no signals store binds: `observe` never touches the
+ * The `signals` a host with no System One or no signals store binds: `observe` never touches the
  * network, answers `invalid` for an input that breaks the recorded-name grammar exactly as a
  * real host would, and otherwise `unavailable` with `stored: false`; both reads answer
  * `unavailable` with reason `no-store`. So a caller's result handling does not change with host
@@ -700,17 +700,6 @@ declare function Create(hidden: ObjectLike_2, enumerable: ObjectLike_2, options?
  */
 export declare function createFallbackOnlySignals(): KayAppSignals;
 
-/**
- * The `withJev` a host with no Jev lane binds: `use` is never called, no client is ever built,
- * and no network is ever touched. It keeps the cancellation contract identical to the real
- * wrapper's so a caller's `signal`/`deadlineAt` handling does not change with host composition.
- *
- * Deliberately here rather than in the runtime: this is the DEFAULT for the SDK's own host
- * factory, which cannot import the runtime uphill. The runtime also delegates fallback execution
- * here, so both paths share cancellation, deadline enforcement, and cleanup.
- */
-export declare function createFallbackOnlyWithJev(): WithJev;
-
 /**
  * The `app.skills` a host with no skill store or catalog binds: every read answers
  * `not-available`, so a plugin's code path never depends on host composition.
@@ -816,6 +805,8 @@ declare type DaemonServiceTurnMessage = CustomMessage<DaemonServiceTurnDetails>
     readonly display: true;
 };
 
+declare type DecideAnswer = DecideBoolAnswer | DecideChoiceAnswer | DecideScoreAnswer;
+
 declare type DecideAnswerFor<Q> = Q extends DecideBoolQuestion ? DecideBoolAnswer : Q extends DecideChoiceQuestion<infer L> ? DecideChoiceAnswer<L> : Q extends DecideScoreQuestion ? DecideScoreAnswer : never;
 
 declare interface DecideBoolAnswer {
@@ -1795,150 +1786,6 @@ declare function IsUnsafe(value: unknown): value is TUnsafe;
 /** Returns true if the given value is TVoid. */
 declare function IsVoid(value: unknown): value is TVoid;
 
-export declare type JevAnswer = JevBoolAnswer | JevChoiceAnswer | JevScoreAnswer;
-
-/** The answer shape one question gets back. */
-export declare type JevAnswerFor<Q> = Q extends JevBoolQuestion ? JevBoolAnswer : Q extends JevChoiceQuestion<infer L> ? JevChoiceAnswer<L> : Q extends JevScoreQuestion ? JevScoreAnswer : never;
-
-export declare interface JevBoolAnswer {
-    readonly type: "bool";
-    /** P(yes), from 0 to 1. */
-    readonly probability: number;
-}
-
-/** A yes/no question. `criteria` says what yes and what no mean; omit it to leave both open. */
-export declare interface JevBoolQuestion {
-    readonly type: "bool";
-    readonly instructions: string;
-    readonly criteria?: {
-        readonly true: string;
-        readonly false: string;
-    };
-}
-
-/**
- * The one error `classify` rejects with. It carries a classification, never the provider's own
- * message or body: those can echo the request state, and this error reaches logs.
- */
-export declare class JevCallError extends Error {
-    readonly transport: JevTransport;
-    readonly kind: JevCallErrorKind;
-    /** The final attempt's HTTP status, when a response arrived. */
-    readonly status: number | undefined;
-    constructor(init: {
-        readonly transport: JevTransport;
-        readonly kind: JevCallErrorKind;
-        readonly status?: number | undefined;
-    });
-}
-
-/**
- * Why a Jev call failed, as a closed set:
- *
- * - `http`: the route answered with an error status (`status` says which).
- * - `too-large`: the route refused the request's size (413, or a 400 naming the token limit).
- * - `network`: no response arrived.
- * - `aborted`: the call was cancelled.
- * - `invalid-answer`: the route answered, but not with an answer for every asked question.
- */
-export declare type JevCallErrorKind = "http" | "too-large" | "network" | "aborted" | "invalid-answer";
-
-export declare interface JevChoiceAnswer<L extends string = string> {
-    readonly type: "choice";
-    readonly choice: L;
-    readonly confidence: number;
-    /** P(label) for every offered label. */
-    readonly probabilities: Readonly<Record<L, number>>;
-}
-
-/** A choice among labels. Each label maps to what it means; an empty string leaves it open. */
-export declare interface JevChoiceQuestion<L extends string = string> {
-    readonly type: "choice";
-    readonly instructions: string;
-    readonly criteria: Readonly<Record<L, string>>;
-}
-
-/** One answered request: every asked question has an answer of its own kind. */
-export declare interface JevClassification<Q extends JevQuestions = JevQuestions> {
-    /** The Jev model the host asked. */
-    readonly model: string;
-    readonly answers: {
-        readonly [K in keyof Q]: JevAnswerFor<Q[K]>;
-    };
-    /** Token counts, when the route reported them. */
-    readonly usage?: {
-        readonly inputTokens: number;
-        readonly outputTokens: number;
-    };
-}
-
-export declare interface JevClassifyRequest<Q extends JevQuestions = JevQuestions> {
-    readonly state: JevState;
-    readonly questions: Q;
-}
-
-/**
- * The Jev client a `use` body receives. `classify` either resolves with an answer for every
- * asked question, each of its question's kind, or rejects with a {@link JevCallError}; it never
- * resolves with a partial or substituted answer.
- */
-export declare interface JevClient {
-    classify<const Q extends JevQuestions>(request: JevClassifyRequest<Q>, options?: {
-        readonly signal?: AbortSignal;
-    }): Promise<JevClassification<Q>>;
-}
-
-export declare type JevQuestion = JevBoolQuestion | JevChoiceQuestion | JevScoreQuestion;
-
-/** A rubric: questions keyed by the name each answer comes back under. */
-export declare type JevQuestions = Readonly<Record<string, JevQuestion>>;
-
-export declare interface JevScoreAnswer {
-    readonly type: "score";
-    /** The expected score, from 0 to the number of rungs minus one. */
-    readonly score: number;
-    readonly confidence: number;
-}
-
-/** A score over ordered rungs: the first criterion scores 0, the next 1, and so on. */
-export declare interface JevScoreQuestion {
-    readonly type: "score";
-    readonly instructions: string;
-    readonly criteria: readonly string[];
-}
-
-/**
- * ---
- * responsibility: The plugin-facing CONTRACT for Jev typed-decision inference — the shape of
- *   `api.withJev` on both plugin SDK targets, the {@link JevClient} a `use` body receives, the
- *   question and answer vocabulary it speaks, and the fallback-only implementation a host
- *   without a Jev lane binds.
- * owns:
- *   - {@link WithJev}, {@link WithJevOptions}, {@link createFallbackOnlyWithJev}.
- *   - {@link JevClient}, the {@link JevQuestion} and {@link JevAnswer} vocabulary, and
- *     {@link JevCallError}.
- * does_not_own:
- *   - The wire. The host serves `classify` over whichever route the user's Jev provider order
- *     picks; a plugin never sees a vendor client, a vendor type, or a route.
- *   - Credential resolution, the `jev.use` decision, the Jev-branch budget, or usage accounting.
- *     Those are host-side (`@bonsai/agent-runtime`'s `kay/jev/`).
- * ---
- *
- * The vocabulary is Bonsai's own (SDK 0.12.0). Before it, `use` received TypeSafe's `TypeSafeClient`
- * and plugins coded against a vendor's types. It follows pi's classifier contract, which the host
- * runs Jev through: a yes/no question is `bool` and answers a `probability`, every instruction and
- * criterion is text, and the state is a JSON object.
- */
-/**
- * The state a rubric reads: a JSON object, never text or an array. Every value must survive
- * `JSON.stringify` unchanged (no functions or class instances), because it is sent as JSON.
- * Typed as `object` so a state declared as an interface fits without an index signature.
- */
-export declare type JevState = object;
-
-/** The route a Jev call took: the user's own TypeSafe key, or Bonsai's hosted gateway. */
-export declare type JevTransport = "direct" | "hosted";
-
 declare type JsonObject = {
     [key: string]: JsonValue_4;
 };
@@ -3263,12 +3110,28 @@ export declare interface KayAppCorpusSession {
      * is unknown, not `user`.
      */
     readonly origin?: KayAppSessionOrigin | undefined;
+    /** Resolved session title from the live index, when one exists. */
+    readonly title?: string | undefined;
+    /** Session creation time in ISO-8601 UTC, when the index has it. */
+    readonly createdAt?: string | undefined;
+    /** Last conversation activity in ISO-8601 UTC, when the index has it. */
+    readonly updatedAt?: string | undefined;
+    /** Current execution directory, when the index has it. */
+    readonly cwd?: string | undefined;
+    /** Persisted project binding; `null` means explicitly unassigned. */
+    readonly projectId?: string | null | undefined;
+    /** Parent session for a spawned member, when lineage is indexed. */
+    readonly parentSessionId?: string | null | undefined;
+    /** Family root session identity, when lineage is indexed. */
+    readonly rootSessionId?: string | undefined;
 }
 
 /** Cheap identity for the current contents of one stored session transcript. */
 export declare interface KayAppCorpusSourceMark {
     readonly mtimeMs: number;
     readonly sizeBytes: number;
+    /** Opaque content/source identity; absent on legacy or test corpus implementations. */
+    readonly sourceRevision?: string | undefined;
 }
 
 /** A newly persisted AgentSession. */
@@ -4043,35 +3906,24 @@ export declare interface KayAppPluginApi {
     readonly config?: KayAppConfig;
     /** Current plugin-safe model metadata from the host's model catalog. */
     readonly models: KayAppModels;
-    /**
-     * Jev typed-decision inference, as an OPTIONAL accelerator with a REQUIRED fallback. Each call
-     * is checked against `jev.use` — but a refused grant or no usable Jev provider both
-     * produce the same outcome: your `fallback` runs.
-     *
-     * Always present, on every host, unlike the grant-gated and host-fact-gated members above. That
-     * is the point: with no absent state to feature-detect, there is no shape of code that reaches
-     * Jev without having written the baseline too. Do not guard it with
-     * `if (app.withJev !== undefined)`.
-     */
-    readonly withJev: WithJev;
     /**
      * System One: fast, cheap judgment calls (`decide`) and typed field extraction (`extract`) on
-     * small models (Jev, Clef, Clef Flash, Clairic). Each call is checked against `jev.use`; a call
-     * that cannot be served or is not permitted throws a `SystemOneError` whose `cause.kind` says
+     * small models (Jev, Clef, Clef Flash, Clairic). Each call is checked against `systemOne.use`; a
+     * call that cannot be served or is not permitted throws a `SystemOneError` whose `cause.kind` says
      * why, so put the feature's cheaper path in the call's own `catch`. Always present, on every
      * host. Types: `@bonsai/plugin-sdk/system-one` (SDK 0.13.8).
      */
     readonly systemOne: SystemOneClient;
     /**
      * Recorded Jev signals. `observe` runs a Jev inference and records the answer as a durable,
-     * provenance-stamped row; each call is checked against `jev.use`, and a refused grant, no
+     * provenance-stamped row; each call is checked against `systemOne.use`, and a refused grant, no
      * usable Jev provider, a timeout, or a vendor error all produce the same outcome: an
      * `unavailable` observation with `stored: false`. A name that breaks the recorded-name grammar
      * is refused as `invalid` before any of that. `list` and `listDetectors` read EVERY plugin's
      * recorded signals back, each call checked against `signals.read`, answering `unavailable` or
      * `invalid` instead of rejecting. While the plugin is enabled, no call here rejects; after it is
      * disabled, a kept handle's `list` and `listDetectors` throw synchronously. Always present, on
-     * every host, for the same reason `withJev` is: no shape of code should reach Jev without a
+     * every host, for the same reason `systemOne` is: no shape of code should reach Jev without a
      * defined baseline beside it.
      */
     readonly signals: KayAppSignals;
@@ -4812,6 +4664,96 @@ export declare interface KayAppSessionSummary {
     readonly provenance?: KayAppSessionProvenanceRecord | undefined;
 }
 
+export declare interface KayAppSessionSummaryChunk {
+    readonly goal: string;
+    readonly work: readonly string[];
+    readonly decisions: readonly string[];
+    readonly outcomes: readonly string[];
+    readonly openWork: readonly string[];
+}
+
+export declare interface KayAppSessionSummaryContinuation {
+    readonly version: typeof SUMMARY_VERSION;
+    readonly sessionId: string;
+    readonly sourceRevision: string;
+    readonly phase: "read" | "reduce";
+    readonly cursor?: JsonValue;
+    readonly chunks: readonly KayAppSessionSummaryChunk[];
+    readonly facts: KayAppSessionSummaryFacts;
+    readonly lineage: readonly KayAppSessionSummaryLineageEntry[];
+    readonly pending?: KayAppSessionSummaryPending;
+    readonly reduction?: KayAppSessionSummaryReduction;
+}
+
+export declare type KayAppSessionSummaryCoverage = "complete" | "partial" | "unavailable" | "changed" | "missing";
+
+export declare interface KayAppSessionSummaryFacts {
+    readonly entryCount: number;
+    readonly userTexts: readonly string[];
+    readonly assistantTexts: readonly string[];
+    readonly toolOutcomes: readonly string[];
+    readonly resources: readonly KayAppSessionSummaryResource[];
+    readonly clipped: boolean;
+    readonly lineageOverflow: boolean;
+    readonly malformedRecords: number;
+    readonly oversizedRecords: number;
+}
+
+export declare interface KayAppSessionSummaryLineageEntry {
+    readonly id: string;
+    /** Original transcript entry id for a bounded text segment. */
+    readonly sourceId?: string;
+    readonly parentId: string | null;
+    readonly seq: number;
+    readonly role: string;
+    readonly kind: string;
+    readonly text: string;
+    readonly toolName?: string;
+    readonly outcome?: string;
+    readonly resources: readonly KayAppSessionSummaryResource[];
+}
+
+export declare interface KayAppSessionSummaryPending {
+    readonly startIndex: number;
+    readonly endIndex: number;
+    readonly nextIndex: number;
+    readonly cursor: JsonValue;
+    readonly status: "complete" | "more" | "awaiting-append" | "record-too-large";
+}
+
+export declare interface KayAppSessionSummaryReduction {
+    readonly phase: "map" | "reduce";
+    readonly sourceIndex: number;
+    readonly queue: readonly KayAppSessionSummaryChunk[];
+}
+
+export declare interface KayAppSessionSummaryResource {
+    readonly uri: string;
+    readonly title: string;
+    readonly entryId: string;
+}
+
+export declare interface KayAppSessionSummaryResult {
+    readonly summaryVersion: number;
+    readonly sessionId: string;
+    readonly sourceRevision: string;
+    readonly coverage: KayAppSessionSummaryCoverage;
+    readonly summary: KayAppSessionWorkSummary;
+    readonly resources: readonly KayAppSessionSummaryResource[];
+    readonly modelCalls: number;
+    /** Present for unavailable coverage, bounded to 600 characters. */
+    readonly unavailableReason?: string;
+    readonly continuation?: KayAppSessionSummaryContinuation;
+}
+
+export declare interface KayAppSessionWorkSummary {
+    readonly goal: string;
+    readonly work: readonly string[];
+    readonly decisions: readonly string[];
+    readonly outcomes: readonly string[];
+    readonly openWork: readonly string[];
+}
+
 /** One stored signal: the answers exactly as Jev gave them, and where the observed turn is. */
 export declare interface KayAppSignal {
     /** Recording order: a higher id was recorded later. */
@@ -4838,8 +4780,8 @@ export declare interface KayAppSignal {
     readonly inputDigest: string;
 }
 
-/** One stored answer: a {@link JevAnswer}, or a yes/no answer recorded before SDK 0.12.0. */
-export declare type KayAppSignalAnswer = JevAnswer | KayAppSignalNoulAnswer;
+/** One stored answer: a {@link DecideAnswer}, or a yes/no answer recorded before SDK 0.12.0. */
+export declare type KayAppSignalAnswer = DecideAnswer | KayAppSignalNoulAnswer;
 
 /** One version of one detector, under one rubric, as the catalog lists it. */
 export declare interface KayAppSignalDetector {
@@ -4868,7 +4810,7 @@ export declare interface KayAppSignalNoulAnswer {
 /**
  * The result of one observe call. `status` is the only field a caller must switch on:
  *
- * - `classified`: Jev answered; `answers` (one {@link JevAnswer} per question), `model`, and
+ * - `classified`: Jev answered; `answers` (one {@link DecideAnswer} per question), `model`, and
  *   `usage` are what the Jev call returned, and `stored` says whether the row landed in the
  *   durable store.
  * - `unavailable`: Jev could not answer (no key, refused grant, timeout, vendor error, or a
@@ -4917,6 +4859,25 @@ export declare interface KayAppSignalObservation {
     readonly recordedAtMs: number;
 }
 
+/** Per-call knobs for {@link KayAppSignals.observe}. Every field is optional; the host applies its
+ *  own default budget when none is given, so the Jev branch is never unbounded. */
+export declare interface KayAppSignalObserveOptions {
+    /**
+     * Explicit cancellation. Always propagates as a rejection, because an aborted call means
+     * "stop", not "record nothing and carry on".
+     */
+    readonly signal?: AbortSignal;
+    /** Bounds the Jev branch alone, measured from the call. */
+    readonly timeoutMs?: number;
+    /**
+     * Absolute epoch-ms hard deadline for the whole call. A deadline already passed rejects (like
+     * `signal`); one still ahead derives the Jev branch's budget from it.
+     */
+    readonly deadlineAt?: number;
+    /** Attribution slug for host usage accounting. Never sent to Jev. */
+    readonly purpose?: string;
+}
+
 /** One page of signals, oldest recorded first. */
 export declare interface KayAppSignalPage {
     readonly signals: readonly KayAppSignal[];
@@ -5081,7 +5042,7 @@ export declare interface KayAppSignalsObserveInput {
      * transcript the source points at. So the projection must be a pure function of the
      * transcript and the detector version, or the row's evidence cannot be reproduced.
      */
-    readonly state: JevState;
+    readonly state: KayAppSignalState;
     /**
      * The typed questions to answer. Stored once per digest. A
      * rubric asks 1 to 64 questions. Each name is an identifier (letters, digits, and `_`, not
@@ -5090,8 +5051,8 @@ export declare interface KayAppSignalsObserveInput {
      * characters with no `,`, `@`, or control or invisible character (`\p{C}`), and no whitespace
      * but single spaces between words, so a reader can copy it back exactly from rendered text.
      */
-    readonly questions: JevQuestions;
-    readonly options?: WithJevOptions;
+    readonly questions: DecideQuestions;
+    readonly options?: KayAppSignalObserveOptions;
 }
 
 /**
@@ -5172,6 +5133,9 @@ export declare interface KayAppSignalsSessionQuery {
     readonly limit?: number;
 }
 
+/** The state a signal's questions are asked over: any object, projected from the transcript. */
+export declare type KayAppSignalState = object;
+
 /**
  * What a signal is about, named by the recording plugin. The host stores both values and never
  * interprets them. A signal recorded without a subject has none; every reader treats it as before.
@@ -8572,6 +8536,17 @@ declare type SubagentResultMessage = CustomMessage<SubagentResultDetails> & {
     readonly display: boolean;
 };
 
+export declare interface SummarizeSessionInput {
+    readonly corpus: KayAppCorpus;
+    readonly models: KayAppModels;
+    readonly sessionId: string;
+    readonly previous?: KayAppSessionSummaryResult;
+    readonly maxModelCalls?: number;
+    readonly signal?: AbortSignal;
+}
+
+declare const SUMMARY_VERSION: 4;
+
 /** Creates a Symbol type. */
 declare function Symbol_2(options?: TSchemaOptions): TSymbol;
 
@@ -13851,53 +13826,6 @@ declare const WithElementList_0: (input: string, result?: unknown[]) => [unknown
 
 declare function WithElementListMapping(input: [unknown, unknown, unknown] | []): unknown;
 
-/**
- * Run `use` against a live Jev client, falling back to `fallback` whenever Jev cannot serve the
- * call. The wrapper exists so a feature can ASK for a typed decision without ever depending on
- * one: `fallback` is required, and it runs whenever no provider in the user's Jev provider
- * order holds a usable credential, the user has not granted `jev.use`, the branch exceeds its budget, `use` throws, or
- * `use` declines by returning `undefined`. With valid options, this rejects on an explicit
- * `signal` abort, reaching `deadlineAt`, or `fallback` itself throwing.
- *
- * ALWAYS PRESENT on the plugin API, on every host. A host that composed no Jev lane binds
- * {@link createFallbackOnlyWithJev}, so a caller never branches on availability — branching is
- * exactly how a fallback gets skipped.
- *
- * `jev` is a {@link JevClient} on the host's Jev model. It is valid only for the duration of
- * the callback: a reference retained past `use`'s scope is refused at the transport, and an
- * in-flight request is aborted when the call stops waiting.
- * The callback itself is ABANDONED, not interrupted — a host cannot stop arbitrary JavaScript
- * that is already running, so `use` must not perform side effects it would mind completing
- * unobserved. The same applies to a running fallback: abort/deadline stops waiting for it but
- * cannot interrupt its JavaScript.
- */
-export declare type WithJev = <T>(
-/** Return `undefined` to decline (the fallback runs). A feature whose real result can itself be
- *  `undefined` should return `null` or its own wrapper type instead. */
-use: (jev: JevClient) => T | undefined | PromiseLike<T | undefined>, 
-/** Required. The behaviour the feature has without Jev. */
-fallback: () => T | PromiseLike<T>, options?: WithJevOptions) => Promise<T>;
-
-/** Per-call knobs for {@link WithJev}. Every field is optional; the host applies its own default
- *  budget when none is given, so the Jev branch is never unbounded. */
-export declare interface WithJevOptions {
-    /**
-     * Explicit cancellation. Always propagates as a rejection; never substituted with `fallback`,
-     * because an aborted call means "stop", not "use the cheaper path".
-     */
-    readonly signal?: AbortSignal;
-    /** Bounds the Jev branch alone, measured from the call. */
-    readonly timeoutMs?: number;
-    /**
-     * Absolute epoch-ms hard deadline for the WHOLE call, `fallback` included. A deadline already
-     * passed rejects (like `signal`); one still ahead derives the Jev branch's budget from it and
-     * keeps a small reserve so `fallback` has a window to run.
-     */
-    readonly deadlineAt?: number;
-    /** Attribution slug for host usage accounting. Never sent to Jev. */
-    readonly purpose?: string;
-}
-
 declare function WithMapping(input: [unknown, unknown] | []): unknown;
 
 declare const WithNull: (input: string) => [unknown, string] | [];

package/dist/kay-app.js

@@ -11,80 +11,6 @@ var JsonValue = z.lazy(() => z.union([
 var JsonObject = z.record(z.string(), JsonValue);
 var JsonSchema = z.record(z.string(), JsonValue);
 
-// packages/plugin-sdk/dist/jev.js
-var JevCallError = class extends Error {
-  transport;
-  kind;
-  /** The final attempt's HTTP status, when a response arrived. */
-  status;
-  constructor(init) {
-    super(`Jev call failed on the ${init.transport} route: ${init.kind}${init.status === void 0 ? "" : ` (HTTP ${init.status})`}.`);
-    this.name = "JevCallError";
-    this.transport = init.transport;
-    this.kind = init.kind;
-    this.status = init.status;
-  }
-};
-function createFallbackOnlyWithJev() {
-  return async (_use, fallback, options = {}) => {
-    if (typeof fallback !== "function") {
-      throw new TypeError("withJev requires a `fallback` function as its second argument.");
-    }
-    const { signal, deadlineAt } = options;
-    if (deadlineAt !== void 0 && !Number.isFinite(deadlineAt)) {
-      throw new TypeError("withJev's `deadlineAt` must be a finite epoch-ms timestamp.");
-    }
-    const assertWithinBoundaries = () => {
-      if (signal?.aborted === true) {
-        throw signal.reason ?? new DOMException("Aborted", "AbortError");
-      }
-      if (deadlineAt !== void 0 && Date.now() >= deadlineAt) {
-        throw new Error("withJev's deadline has passed.");
-      }
-    };
-    assertWithinBoundaries();
-    let timer;
-    let onAbort;
-    const stopped = new Promise((_resolve, reject) => {
-      if (signal !== void 0) {
-        onAbort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      if (deadlineAt !== void 0) {
-        const checkDeadline = () => {
-          const remaining = deadlineAt - Date.now();
-          if (remaining <= 0) {
-            reject(new Error("withJev's deadline has passed."));
-          } else {
-            timer = setTimeout(checkDeadline, Math.min(remaining, 2147483647));
-          }
-        };
-        checkDeadline();
-      }
-    });
-    try {
-      const result = await Promise.race([
-        Promise.resolve().then(() => {
-          assertWithinBoundaries();
-          return fallback();
-        }),
-        stopped
-      ]);
-      assertWithinBoundaries();
-      return result;
-    } catch (error) {
-      assertWithinBoundaries();
-      throw error;
-    } finally {
-      if (timer !== void 0)
-        clearTimeout(timer);
-      if (signal !== void 0 && onAbort !== void 0) {
-        signal.removeEventListener("abort", onAbort);
-      }
-    }
-  };
-}
-
 // packages/plugin-sdk/dist/signals.js
 import { z as z2 } from "zod";
 function createFallbackOnlySignals() {
@@ -92,7 +18,7 @@ function createFallbackOnlySignals() {
   return {
     observe: (input) => Promise.resolve(invalidObservation(input) ?? {
       status: "unavailable",
-      reason: "no-jev-lane",
+      reason: "no-system-one",
       detector: { ...input.detector, rubricDigest: "" },
       source: input.source,
       stored: false,
@@ -591,7 +517,6 @@ var KAY_APP_DATA_CHANGE_MAX_BYTES = 256 * 1024;
 var KAY_APP_DATA_READ_REQUEST_MAX_BYTES = 64 * 1024;
 var KAY_APP_DATA_READ_RESULT_MAX_BYTES = 16 * 1024 * 1024;
 export {
-  JevCallError,
   JsonSchema,
   JsonValue,
   KAY_APP_AUTOMATION_CONDITION_KINDS,
@@ -606,7 +531,6 @@ export {
   UriUnsupportedOperationError,
   UriValidationError,
   createFallbackOnlySignals,
-  createFallbackOnlyWithJev,
   createUnavailableSkills,
   createUnavailableTools,
   createUnavailableUsage,