@deepseek-ai/dsh-session 0.2.0-rc.2 → 0.2.1-alpha.2

package/lib/types/index.js

@@ -324,6 +324,77 @@ function invokeContainedSessionObservers(ctx, name, id, args, callbacks) {
 }
 /** Store attachment for the append path; module-private to keep Session store-agnostic publicly. */
 const attachments = new WeakMap();
+/**
+ * Grammar of a {@link PluginRecordType}: `plugin:` followed by
+ * slash-separated segments of lowercase letters, digits, `.`, `_`, and `-`,
+ * each segment starting with a letter or digit.
+ */
+const PLUGIN_RECORD_TYPE = /^plugin:[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)*$/u;
+/**
+ * Whether one event type name follows the plugin record grammar.
+ * @param type - an event type name.
+ * @returns whether the name is a {@link PluginRecordType}.
+ */
+function isPluginRecordType(type) {
+    return PLUGIN_RECORD_TYPE.test(type);
+}
+/**
+ * Type one constructed plugin record as a log event after checking its type
+ * against the plugin record grammar. A restored Session already holds events
+ * whose types are outside `SessionEventMap` when they are marked ignorable;
+ * a plugin record is such an event.
+ * @param value - the frozen record envelope built by {@link Session}.
+ * @throws when the record type is outside the plugin record grammar.
+ */
+function assertPluginRecordEvent(value) {
+    const { type } = value;
+    if (!isPluginRecordType(type)) {
+        throw new Error(`plugin record type "${type}" must be "plugin:" followed by lowercase slash-separated segments`);
+    }
+}
+/** Module-private access to {@link Session}'s record commit, assigned once by its static block. */
+let commitPluginRecord;
+/**
+ * Append one experimental plugin record: an event marked `ignorable` whose
+ * type is declared in {@link PluginRecordMap}, outside {@link SessionEventMap}.
+ * The plugin record catalog lists it separately from released event schemas.
+ * A reader that does not recognize the type retains and skips the record, which never
+ * enters the model-visible surface, and fork and resume carry it with the rest
+ * of the log. A Session format migration retains records on a best-effort
+ * basis, so a record holds plugin-owned state that its owner can lose without
+ * changing how the rest of the log is interpreted.
+ *
+ * Only production source under `packages/experimental/` may call this
+ * function; the `verify-plugin-record-callers` gate rejects any other
+ * production caller in this repository. Read records back with
+ * {@link pluginRecordOf}.
+ * @param session - the Session whose log receives the record.
+ * @param type - declared record name: `plugin:` followed by slash-separated
+ *   segments of lowercase letters, digits, `.`, `_`, and `-`, each starting
+ *   with a letter or digit.
+ * @param data - JSON payload, snapshotted before it enters the log.
+ * @returns the sequence number of the committed record.
+ * @throws when `type` is outside that grammar, when `data` is not losslessly
+ *   JSON-serializable, or when the call reenters another append's publication;
+ *   a rejected record does not change the log.
+ */
+export function appendPluginRecord(session, type, data) {
+    return commitPluginRecord(session, type, data);
+}
+/**
+ * Read one committed event as a plugin record. The V3-to-V4 format edge also
+ * renames each unknown ignorable V3 event into the `plugin:` namespace, so an
+ * owner names its records under its own package name and validates `data`.
+ * @param event - any committed Session event, live or restored.
+ * @returns the record, or undefined when the event is not an ignorable event
+ *   whose type follows the plugin record grammar.
+ */
+export function pluginRecordOf(event) {
+    const type = event.type;
+    if (event.ignorable !== true || !isPluginRecordType(type))
+        return undefined;
+    return { type, seq: event.seq, time: event.time, data: event.data };
+}
 /**
  * An event-sourced session: an append-only log of {@link SessionEvent}s.
  *
@@ -578,10 +649,7 @@ export class Session {
         if (surfaceMetadataSnapshot === undefined) {
             throw new Error(`session event "${type}" carries non-JSON-serializable surface metadata`);
         }
-        const entry = attachments.get(this);
-        if (entry?.appending) {
-            throw new Error('session append cannot reenter while another append is being published');
-        }
+        const entry = this.publicationEntry();
         const event = deepFreeze({
             type,
             seq: SessionSeq(this.log.length),
@@ -590,6 +658,54 @@ export class Session {
             ...surfaceMetadataSnapshot,
         });
         validateSessionEventData(event, `session event "${type}" at seq ${event.seq}`);
+        this.commit(event, entry);
+        return event;
+    }
+    static {
+        commitPluginRecord = (session, type, data) => session.#appendRecord(type, data);
+    }
+    /**
+     * Commit one plugin record; {@link appendPluginRecord} is the only caller.
+     * @param type - record type, checked against the plugin record grammar.
+     * @param data - JSON payload, snapshotted before it enters the log.
+     * @returns the record's sequence number.
+     */
+    #appendRecord(type, data) {
+        const dataSnapshot = snapshotJsonValue(data);
+        if (dataSnapshot === undefined) {
+            throw new Error(`plugin record "${type}" carries non-JSON-serializable data`);
+        }
+        const entry = this.publicationEntry();
+        const record = deepFreeze({
+            type,
+            seq: SessionSeq(this.log.length),
+            time: Date.now(),
+            data: dataSnapshot,
+            ignorable: true,
+        });
+        assertPluginRecordEvent(record);
+        this.commit(record, entry);
+        return record.seq;
+    }
+    /**
+     * Read the store attachment for one append, refusing an append that
+     * reenters while another append is being published.
+     * @returns the attachment, or undefined for a detached Session.
+     */
+    publicationEntry() {
+        const entry = attachments.get(this);
+        if (entry?.appending) {
+            throw new Error('session append cannot reenter while another append is being published');
+        }
+        return entry;
+    }
+    /**
+     * Accept one frozen candidate at the next sequence number, enter it into the
+     * log, and notify `session/event` observers with per-listener containment.
+     * @param event - the candidate built at the current log length.
+     * @param entry - the attachment read before the candidate was built.
+     */
+    commit(event, entry) {
         this.surfaceManager.validateNext(event);
         if (entry !== undefined)
             entry.appending = true;
@@ -604,7 +720,6 @@ export class Session {
             if (callbacks !== undefined && entry !== undefined) {
                 invokeContainedSessionObservers(entry.emitCtx, 'session/event', entry.id, callbackArgs, callbacks);
             }
-            return event;
         }
         finally {
             if (entry !== undefined) {
@@ -999,8 +1114,8 @@ export class SessionStore extends Service {
      * store owns the carrier, so callers (the checkpoint policy's per-request
      * barrier, goal-round-driver's idle checkpoint, teardown drains, and consumers
      * that flush themselves before reading storage) must come through here
-     * rather than dispatch a raw `ctx.parallel('session/flush', …)` — one owner,
-     * one spelling, and the scoped-dispatch invariant can pin it.
+     * rather than dispatch a raw `ctx.parallel('session/flush', …)` — one owner
+     * and one spelling.
      * @param session - the session whose buffered events must reach durable storage.
      * @returns whether at least one durability listener participated, after every
      *   listener has settled successfully.

package/lib/types/known-event-types.js

@@ -77,6 +77,7 @@ export const KNOWN_SESSION_EVENT_TYPES = new Set([
     'turn/start',
     'user/message',
     'web/deepseek-search-llm-request',
+    'working-directory/change',
     'workspace/changes',
 ]);
 /** Event types whose model-visible effects require an explicit pure interpreter. */

package/lib/types/surface.js

@@ -80,14 +80,8 @@ export function deriveEventMessage(event, projectedMessages) {
     // history; turn/step boundaries, failed attempts, and errors are trace/replay
     // data.
     switch (event.type) {
-        // Ordinary prompts and injected context project in user role: the event's
-        // model-facing content stays verbatim. Do NOT re-add per-type framing
-        // (e.g. `<context>`) here: framing is caller-owned — a producer bakes it
-        // into `content`, as agent-instructions does with `<system-reminder>` — or,
-        // if reintroduced, must be driven by the event `meta` map and a dedicated
-        // renderer, keeping this projection a verbatim pass-through. See the
-        // deferred design note in
-        // ../../../../.agents/notes/implemented/simplification/2026-07-20-unwrap-injected-content-envelopes.md
+        // Ordinary prompts and injected context retain producer-owned framing.
+        // See Derived history in packages/core/session/README.md.
         case 'user/message': {
             return event.data;
         }

package/lib/types/types.d.ts

@@ -36,20 +36,20 @@ export type OptionalSessionSeq = SessionSeq | null;
  * event-body read composes the build-static adjacent chain and publishes only
  * this final generation before constructing a Session.
  *
- * The version is a single monotonic integer with no major/minor split. Whether
- * a bump is needed is decided by what the WRITER emits, never by what a newer
- * reader can accept: bump exactly when an older runtime could no longer handle
- * a new log with full semantic correctness ("parses without error" is not
- * correctness — silently skipping content that shapes reconstruction is a
- * wrong read). Only structural changes reach that bar: the header shape, the
- * {@link SessionEvent} envelope, core event semantics, or the surface
- * mechanism (the {@link SurfaceEventType} set and {@link SurfaceOp} variants).
- * Adding an ordinary event type does not bump — the per-event
- * {@link SessionEvent.ignorable} guard covers vocabulary growth instead. When
- * in doubt, bump: a near-identity upgrade step is almost free, a missed bump
- * makes older runtimes read new logs wrong silently. The released migration,
- * immutable prior-generation, and current fast-path rules are recorded in
- * `.agents/notes/implemented/architecture/2026-08-31-released-session-format-migrations.md`.
+ * The version is a single monotonic integer with no major/minor split. Retain
+ * it when older readers resume correctly, preserve safely ignorable records,
+ * or refuse required features before execution, mutation, or tail repair.
+ * New readers must preserve historical meanings, including logs mixing old
+ * and new record representations. Bump when an existing discriminator cannot
+ * prevent unsafe interpretation; a structural difference alone is insufficient.
+ * Unknown fields and values require evidence of the released reader's actual
+ * admission behavior. The per-event {@link SessionEvent.ignorable} marker
+ * governs unknown event types, not arbitrary nested payload changes.
+ * Same-version readers retain earlier representations: the adjacent migration
+ * chain does not run when stored and current versions match. A subsequent
+ * migration must account for all supported representations of its source.
+ * Compatibility review and the retained migration obligations are recorded in
+ * `.agents/notes/implemented/process/2026-10-08-session-reader-compatibility-review.md`.
  */
 export declare const SESSION_FORMAT_VERSION = 4;
 /**
@@ -417,8 +417,8 @@ export interface SessionEventMap {
      * keep ordinary restore and replay lifecycle boundaries.
      *
      * Only the `Session` constructor and `buildForkSeed` may create this marker.
-     * The invariant companion deliberately constrains nothing here, so a plugin
-     * appending one would silently classify every live bracket before it as seed history.
+     * Session append does not reject other writers, so a plugin appending one
+     * would silently classify every live bracket before it as seed history.
      *
      * An owner of a standalone open/close bracket (`compaction/start` …
      * `compaction/end`) reads it because seed history and live work are otherwise
@@ -510,6 +510,37 @@ export type SessionEvent<T extends SessionEventType = SessionEventType> = {
         sourceEventSeqs?: never;
     });
 }[T];
+/**
+ * Event type of an experimental plugin record: `plugin:` followed by
+ * slash-separated segments of lowercase letters, digits, `.`, `_`, and `-`,
+ * each starting with a letter or digit. A record type is never a
+ * {@link SessionEventMap} member.
+ */
+export type PluginRecordType = `plugin:${string}`;
+/**
+ * Payloads written by experimental packages, keyed by their `plugin:` record
+ * names. Packages augment this map to type writes and enter the current plugin
+ * record catalog; these declarations do not enter {@link SessionEventMap} or
+ * released persistence schemas. Stored records still require owner validation.
+ */
+export interface PluginRecordMap {
+}
+/**
+ * One committed experimental plugin record, read from the log by
+ * `pluginRecordOf`. The record's owner validates `data` before use, because a
+ * restored record carries whatever JSON an earlier build of its owner wrote,
+ * or a V3 event that a format migration renamed into the `plugin:` namespace held.
+ */
+export interface PluginRecord {
+    /** The record type, chosen by the owning plugin. */
+    readonly type: PluginRecordType;
+    /** The record's position in the Session log. */
+    readonly seq: SessionSeq;
+    /** Unix epoch milliseconds at append. */
+    readonly time: number;
+    /** The JSON payload as committed. */
+    readonly data: unknown;
+}
 declare module '@deepseek-ai/dsh-typert-protocol' {
     interface RemoteErrorDetailsMap {
         /** The named Session does not exist; produced by every layer that resolves a SessionId. */

package/lib/types/types.js

@@ -36,20 +36,20 @@ export function SessionLogOffset(value) {
  * event-body read composes the build-static adjacent chain and publishes only
  * this final generation before constructing a Session.
  *
- * The version is a single monotonic integer with no major/minor split. Whether
- * a bump is needed is decided by what the WRITER emits, never by what a newer
- * reader can accept: bump exactly when an older runtime could no longer handle
- * a new log with full semantic correctness ("parses without error" is not
- * correctness — silently skipping content that shapes reconstruction is a
- * wrong read). Only structural changes reach that bar: the header shape, the
- * {@link SessionEvent} envelope, core event semantics, or the surface
- * mechanism (the {@link SurfaceEventType} set and {@link SurfaceOp} variants).
- * Adding an ordinary event type does not bump — the per-event
- * {@link SessionEvent.ignorable} guard covers vocabulary growth instead. When
- * in doubt, bump: a near-identity upgrade step is almost free, a missed bump
- * makes older runtimes read new logs wrong silently. The released migration,
- * immutable prior-generation, and current fast-path rules are recorded in
- * `.agents/notes/implemented/architecture/2026-08-31-released-session-format-migrations.md`.
+ * The version is a single monotonic integer with no major/minor split. Retain
+ * it when older readers resume correctly, preserve safely ignorable records,
+ * or refuse required features before execution, mutation, or tail repair.
+ * New readers must preserve historical meanings, including logs mixing old
+ * and new record representations. Bump when an existing discriminator cannot
+ * prevent unsafe interpretation; a structural difference alone is insufficient.
+ * Unknown fields and values require evidence of the released reader's actual
+ * admission behavior. The per-event {@link SessionEvent.ignorable} marker
+ * governs unknown event types, not arbitrary nested payload changes.
+ * Same-version readers retain earlier representations: the adjacent migration
+ * chain does not run when stored and current versions match. A subsequent
+ * migration must account for all supported representations of its source.
+ * Compatibility review and the retained migration obligations are recorded in
+ * `.agents/notes/implemented/process/2026-10-08-session-reader-compatibility-review.md`.
  */
 export const SESSION_FORMAT_VERSION = 4;
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-session",
   "description": "Event-sourced session store for the DeepSeek Harness",
-  "version": "0.2.0-rc.2",
+  "version": "0.2.1-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -18,10 +18,6 @@
       "types": "./lib/types/index.d.ts",
       "default": "./lib/index.js"
     },
-    "./invariant": {
-      "types": "./lib/types/invariant.d.ts",
-      "default": "./lib/invariant.js"
-    },
     "./types": {
       "types": "./lib/types/types.d.ts",
       "default": "./lib/types/types.js"
@@ -39,25 +35,23 @@
   },
   "files": [
     "lib/index.js",
-    "lib/invariant.js",
     "lib/types/**/*.js",
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-scope": "0.2.0-rc.2"
+    "@deepseek-ai/dsh-scope": "0.2.1-alpha.2",
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
-    "@deepseek-ai/cordis": "~4.0.4",
-    "@deepseek-ai/dsh-typert-registry": "0.2.0-rc.2"
+    "@deepseek-ai/dsh-scope": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-typert-registry": "0.2.1-alpha.2",
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1"
   },
   "dependencies": {
-    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-brand": "0.2.0-rc.2",
-    "@deepseek-ai/dsh-util-values": "0.2.0-rc.2"
+    "@deepseek-ai/dsh-llm": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-brand": "0.2.1-alpha.2",
+    "@deepseek-ai/dsh-util-values": "0.2.1-alpha.2"
   }
 }

package/lib/invariant.js

@@ -1,174 +0,0 @@
-import { assertNever } from "@deepseek-ai/dsh-util-values";
-import "@deepseek-ai/dsh-brand";
-//#endregion
-//#region lib/types/invariant.js
-/**
-* Package-owned relational invariants for the session event log. Load this
-* companion beside `@deepseek-ai/dsh-invariants` to enable the checks.
-*
-* @module @deepseek-ai/dsh-session/invariant
-*/
-const PACKAGE_NAME = "@deepseek-ai/dsh-session";
-/** Cordis companion plugin name. */
-const name = "session-invariant";
-/** Service required before the companion can reserve package ownership. */
-const inject = ["invariants"];
-/** Assert that a step-scoped event names the currently open turn and step. */
-function requireOpenStep(trace, kind, turn, step, fail) {
-	if (trace.openTurn !== turn || trace.openStep !== step) fail(`${kind} names turn ${turn}/step ${step} but open is turn ${trace.openTurn}/step ${trace.openStep}`);
-}
-/** Validate one candidate event without mutating the committed trace. */
-function validateEvent(trace, event, fail) {
-	if (event.seq <= trace.lastSeq) fail(`seq must strictly increase: saw ${event.seq} after ${trace.lastSeq}`);
-	let openTurn = trace.openTurn;
-	let openStep = trace.openStep;
-	let nextTurn = trace.nextTurn;
-	let nextStep = trace.nextStep;
-	let pendingCalls = { kind: "none" };
-	switch (event.type) {
-		case "turn/start":
-			if (trace.openTurn !== null) fail(`turn/start ${event.data.turn} while turn ${trace.openTurn} is still open`);
-			if (event.data.turn !== trace.nextTurn) fail(`turn/start expected turn ${trace.nextTurn}, got ${event.data.turn}`);
-			openTurn = event.data.turn;
-			nextStep = 1;
-			break;
-		case "turn/end":
-			if (trace.openTurn !== event.data.turn) fail(`turn/end ${event.data.turn} does not match open turn ${trace.openTurn}`);
-			if (trace.openStep !== null) fail(`turn/end ${event.data.turn} while step ${trace.openStep} is still open`);
-			openTurn = null;
-			nextTurn += 1;
-			break;
-		case "step/start":
-			if (trace.openTurn !== event.data.turn) fail(`step/start in turn ${event.data.turn} but open turn is ${trace.openTurn}`);
-			if (trace.openStep !== null) fail(`step/start ${event.data.step} while step ${trace.openStep} is still open`);
-			if (event.data.step !== trace.nextStep) fail(`step/start expected step ${trace.nextStep} in turn ${event.data.turn}, got ${event.data.step}`);
-			openStep = event.data.step;
-			break;
-		case "developer/message":
-			requireOpenStep(trace, "developer/message", event.data.turn, event.data.step, fail);
-			break;
-		case "step/end":
-			requireOpenStep(trace, "step/end", event.data.turn, event.data.step, fail);
-			pendingCalls = { kind: "clear" };
-			openStep = null;
-			nextStep += 1;
-			break;
-		case "assistant/attempt":
-			requireOpenStep(trace, "assistant/attempt", event.data.turn, event.data.step, fail);
-			break;
-		case "assistant/message":
-			requireOpenStep(trace, "assistant/message", event.data.turn, event.data.step, fail);
-			break;
-		case "tool/call":
-			requireOpenStep(trace, "tool/call", event.data.turn, event.data.step, fail);
-			pendingCalls = {
-				kind: "add",
-				callId: event.data.callId
-			};
-			break;
-		case "tool/result": {
-			if (event.surfaceOp !== "append") {
-				if (trace.openTurn === null) fail("tool/result surface replacement appended outside any open turn");
-				break;
-			}
-			requireOpenStep(trace, "tool/result", event.data.turn, event.data.step, fail);
-			const callId = event.data.message.source.callId;
-			const syntheticNotStarted = event.data.message.isError === true && event.data.error?.code === "TOOL_NOT_STARTED";
-			if (!trace.pendingCalls.has(callId) && !syntheticNotStarted) fail(`tool/result for ${callId} with no prior tool/call in this step`);
-			pendingCalls = {
-				kind: "delete",
-				callId
-			};
-			break;
-		}
-		case "system/message":
-			requireOpenStep(trace, "system/message", event.data.turn, event.data.step, fail);
-			break;
-		case "user/message": break;
-		case "session/end-seed": break;
-		case "request/header":
-		case "request/context":
-			if (trace.openTurn === null) fail(`${event.type} appended outside any open turn (core execution events must be turn-enclosed)`);
-			break;
-		default: break;
-	}
-	return {
-		scalars: {
-			lastSeq: event.seq,
-			openTurn,
-			openStep,
-			nextTurn,
-			nextStep
-		},
-		pendingCalls
-	};
-}
-/** Apply one already-validated transition after its event commits. */
-function applyTransition(trace, transition) {
-	Object.assign(trace, transition.scalars);
-	switch (transition.pendingCalls.kind) {
-		case "none": break;
-		case "add":
-			trace.pendingCalls.add(transition.pendingCalls.callId);
-			break;
-		case "delete":
-			trace.pendingCalls.delete(transition.pendingCalls.callId);
-			break;
-		case "clear":
-			trace.pendingCalls.clear();
-			break;
-		/* v8 ignore next -- validateEvent produces this closed transition union */
-		default: assertNever(transition.pendingCalls, "session trace pending-call transition");
-	}
-}
-/** Install the session contribution into its child registration fiber. */
-const install = Object.assign((ctx, fail) => {
-	const traces = /* @__PURE__ */ new WeakMap();
-	const stagedTransitions = /* @__PURE__ */ new WeakMap();
-	const freshTrace = () => ({
-		lastSeq: -1,
-		openTurn: null,
-		openStep: null,
-		nextTurn: 1,
-		nextStep: 1,
-		pendingCalls: /* @__PURE__ */ new Set()
-	});
-	const seedSession = (session) => {
-		const trace = freshTrace();
-		traces.set(session, trace);
-		for (const event of session.snapshotEvents()) applyTransition(trace, validateEvent(trace, event, fail));
-		return trace;
-	};
-	/* v8 ignore next -- session/event always follows list() or session/created seeding */
-	const traceFor = (session) => traces.get(session) ?? seedSession(session);
-	for (const session of ctx.sessions.list()) seedSession(session);
-	ctx.on("session/created", (session) => {
-		seedSession(session);
-	}, { global: true });
-	ctx.on("session/event", (session, event) => {
-		const staged = stagedTransitions.get(event);
-		/* v8 ignore next 2 -- internal/dispatch stages the exact callback arguments */
-		if (staged === void 0 || staged.session !== session) return fail("session/event reached publication without matching pre-commit validation");
-		stagedTransitions.delete(event);
-		applyTransition(staged.trace, staged.transition);
-	}, { global: true });
-	ctx.on("internal/dispatch", (_mode, eventName, args) => {
-		if (eventName !== "session/event") return;
-		const [session, event] = args;
-		const trace = traceFor(session);
-		const transition = validateEvent(trace, event, fail);
-		stagedTransitions.set(event, {
-			session,
-			trace,
-			transition
-		});
-	}, { global: true });
-}, { inject: ["sessions"] });
-/**
-* Register the session invariant companion.
-* @param ctx - Cordis context carrying the invariant service.
-* @returns the installed registration's disposer after setup succeeds.
-*/
-const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
-//#endregion
-export { apply, inject, name };

package/lib/types/invariant.d.ts

@@ -1,18 +0,0 @@
-/**
- * Package-owned relational invariants for the session event log. Load this
- * companion beside `@deepseek-ai/dsh-invariants` to enable the checks.
- *
- * @module @deepseek-ai/dsh-session/invariant
- */
-import type { Context } from '@deepseek-ai/cordis';
-/** Cordis companion plugin name. */
-export declare const name = "session-invariant";
-/** Service required before the companion can reserve package ownership. */
-export declare const inject: string[];
-/**
- * Register the session invariant companion.
- * @param ctx - Cordis context carrying the invariant service.
- * @returns the installed registration's disposer after setup succeeds.
- */
-export declare const apply: (ctx: Context) => Promise<() => void>;
-//# sourceMappingURL=invariant.d.ts.map