@vibesdotdev/session 0.0.0-stage → 1.0.0-rc.1

package/dist/events/session.bound.event.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.bound.event.descriptor.d.ts","sourceRoot":"","sources":["../../src/events/session.bound.event.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAC3B,OAAO,EAEN,YAAY,EACZ,MAAM,qBAAqB,CAAC;AAE7B,oEAAoE;AACpE,eAAO,MAAM,uBAAuB,YAAY,CAAC;AACjD,0EAA0E;AAC1E,eAAO,MAAM,wBAAwB,UAAU,CAAC;AAChD,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,kBAAkB,CAAC;AAEtD;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;iBAiBlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,iBAAiB;;;;;;;CAQ5B,CAAC;AAEH,kEAAkE;AAClE,MAAM,WAAW,qBAAqB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,GACpB,IAAI,CAQN;AAED,wEAAwE;AACxE,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,qBAAqB,GAAG,IAAI,CAMzF;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ9E;AAED,eAAO,MAAM,uBAAuB;;;;;;;EAA+B,CAAC;AAEpE,eAAe,iBAAiB,CAAC"}

package/dist/events/session.bound.event.descriptor.js

@@ -0,0 +1,121 @@
+/**
+ * `session.bound` — a reusable runtime lifecycle event.
+ *
+ * Fired by a surface (MCP serve, CLI bootstrap, autoloop) once it has bound
+ * (created or adopted) a session for a participant. It is a runtime-native
+ * `runtime/event` — the SAME publish/subscribe machinery the awareness on-tool
+ * hooks use (`runtime/src/hooks/` + the `tools.tool.*` event
+ * descriptors) — so a single emit propagates to every interested slice (scope
+ * publish, awareness turn.start) with NO per-harness code.
+ *
+ * `emitSessionBound` commits the session and caller participant identity as
+ * the runtime's bound invocation actor synchronously before hook fanout. A
+ * declared scope carries no identity (RC01 Q4): the kernel starts each later
+ * outermost invocation from the bound actor, so readers see the bind as
+ * `runtime.scope.actor.sessionId` / `.participantId`. Subscribers
+ * (each a `runtime/subscription`, wired
+ * generically by the hooks
+ * wirer):
+ *   - `session.subscriptions.on-session-bound-scope` (this package) — records
+ *     the binding in the session registry, the ONE canonical bound-session
+ *     location, so `brain.pulse` stops falling back to `sessionId:"ephemeral"`.
+ *   - `awareness.hooks.on-session-bound` (awareness) — emits a `turn.start`
+ *     awareness event.
+ *
+ * The wirer maps `{ source: 'session', id: 'session.bound' }` to the bus
+ * `runtime.hooks('session').on('bound', …)`; `emitSessionBound` publishes to
+ * the matching `runtime.hooks('session').emit('bound', …)`.
+ */
+import { z } from 'zod/v4';
+import { createRuntimeAsset, VibesRuntime } from '@vibesdotdev/kernel';
+/** Hook-bus namespace the wirer derives from the event `source`. */
+export const SESSION_BOUND_NAMESPACE = 'session';
+/** Hook-bus event name the wirer derives from the trailing id segment. */
+export const SESSION_BOUND_EVENT_NAME = 'bound';
+/** Runtime/event descriptor id (subscriptions reference this in `event`). */
+export const SESSION_BOUND_EVENT_ID = 'session.bound';
+/**
+ * Payload carried on the `session.bound` bus event.
+ *
+ * `runtime` rides the payload exactly like the `tools/tool` hook events
+ * (`{ toolId, callId, input, runtime, metadata }`), so subscribers act on the
+ * same runtime instance the surface bound — no guessing which
+ * runtime to act on, and parallel runtimes stay isolated.
+ */
+export const SessionBoundEventSchema = z.object({
+    /** The bound (created or adopted) Vibes session id. */
+    sessionId: z.string(),
+    /** The participant the session is bound to, when known. */
+    participantId: z.string().optional(),
+    /** Which surface bound it: 'mcp' | 'cli' | 'autoloop' | … */
+    surface: z.string(),
+    /** The runtime whose scope receives the binding. */
+    runtime: z.instanceof(VibesRuntime),
+    /**
+     * Ambient bindings belong to one-seat runtimes (CLI, stdio). Shared
+     * hosts carry identity on each request and must never write one client's
+     * session into process-global runtime scope.
+     */
+    bindingScope: z.enum(['ambient', 'request']).optional(),
+    /** True when init restored an existing bind rather than creating one. */
+    reused: z.boolean().optional()
+});
+export const sessionBoundEvent = createRuntimeAsset({
+    kind: 'runtime/event',
+    id: SESSION_BOUND_EVENT_ID,
+    source: SESSION_BOUND_NAMESPACE,
+    name: 'Session Bound',
+    description: 'Emitted when a surface binds (creates or adopts) a session for a participant. Source-of-truth lifecycle event consumed by the scope-publish and awareness turn.start subscriptions.',
+    trigger: 'custom'
+});
+/**
+ * Commit the canonical session identity as the runtime's bound invocation
+ * actor (the kernel's one-seat binding: every outermost invocation starts from
+ * it, and a caller's own actor fields win). It is identity, so it never enters
+ * the declared scope.
+ *
+ * This is synchronous and idempotent by design: hook fanout is useful for
+ * awareness and surface-specific rebinding, but a missing or failing
+ * subscriber must never leave the caller on its previous session.
+ */
+export function bindRuntimeSessionScope(runtime, sessionId, participantId) {
+    if (!sessionId)
+        return;
+    // A shared host (MCP host, daemon) serves many seats: its process is
+    // nobody's session. Each connection's binding rides on its own invocation.
+    if (runtime.declaredScope?.capabilities?.sharedHost === true)
+        return;
+    const actor = { sessionId };
+    if (participantId)
+        actor.participantId = participantId;
+    runtime.bindInvocationActor(actor);
+}
+/** The session this runtime is bound to, or null when none is bound. */
+export function runtimeSessionBinding(runtime) {
+    const actor = runtime.boundInvocationActor;
+    if (!actor?.sessionId)
+        return null;
+    const binding = { sessionId: actor.sessionId };
+    if (actor.participantId)
+        binding.participantId = actor.participantId;
+    return binding;
+}
+/**
+ * Publish `session.bound` onto the runtime hook bus.
+ *
+ * Surfaces call this AFTER their (surface-specific) create-or-adopt. The hooks
+ * wirer has already bound the scope-publish + turn.start subscriptions to this
+ * namespace/event, so the single emit fans out runtime-natively.
+ */
+export async function emitSessionBound(event) {
+    // Session identity is the transactional core; subscribers are fanout.
+    if (event.bindingScope !== 'request') {
+        bindRuntimeSessionScope(event.runtime, event.sessionId, event.participantId);
+    }
+    await event.runtime
+        .hooks(SESSION_BOUND_NAMESPACE)
+        .emit(SESSION_BOUND_EVENT_NAME, event);
+}
+export const sessionEventDescriptors = [sessionBoundEvent];
+export default sessionBoundEvent;
+//# sourceMappingURL=session.bound.event.descriptor.js.map

package/dist/events/session.bound.event.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.bound.event.descriptor.js","sourceRoot":"","sources":["../../src/events/session.bound.event.descriptor.ts"],"names":[],"mappings":"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"}

package/dist/events/session.unbound.event.descriptor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `session.unbound` — the close-half of `session.bound`.
+ *
+ * Fired by a surface when it RELEASES a previously bound session — e.g. the MCP
+ * stdio/HTTP transport closing. A runtime-native `runtime/event` on the SAME
+ * publish/subscribe machinery as `session.bound`, so a single emit propagates to
+ * every interested slice with NO per-harness code.
+ *
+ * Subscribers (each a `runtime/subscription`, wired generically by the hooks wirer):
+ *   - `awareness.hooks.on-session-unbound` (awareness) — emits a `turn.end`
+ *     awareness event (the close-half of session.bound → turn.start).
+ *
+ * Deliberately does NOT clear the session registry binding: the surface is tearing
+ * down, and a late reader resolving the just-ended session id is harmless and
+ * preferable to racing a clear against in-flight shutdown work.
+ */
+import { type VibesRuntime } from '@vibesdotdev/kernel';
+/** Hook-bus namespace the wirer derives from the event `source`. */
+export declare const SESSION_UNBOUND_NAMESPACE = "session";
+/** Hook-bus event name the wirer derives from the trailing id segment. */
+export declare const SESSION_UNBOUND_EVENT_NAME = "unbound";
+/** Runtime/event descriptor id (subscriptions reference this in `event`). */
+export declare const SESSION_UNBOUND_EVENT_ID = "session.unbound";
+/**
+ * Payload carried on the `session.unbound` bus event. Mirrors `SessionBoundEvent`:
+ * `runtime` rides the payload so subscribers act on the same runtime instance the
+ * surface bound — no guessing which runtime to act on.
+ */
+export interface SessionUnboundEvent {
+    /** The released (previously bound) Vibes session id. */
+    sessionId: string;
+    /** The participant the session was bound to, when known. */
+    participantId?: string;
+    /** Which surface released it: 'mcp' | 'cli' | 'autoloop' | … */
+    surface: string;
+    /** Why it was released (e.g. 'transport-close', 'SIGINT'), when known. */
+    reason?: string;
+    /** The runtime whose session is being released. */
+    runtime: VibesRuntime;
+}
+export declare const sessionUnboundEvent: {
+    kind: "runtime/event";
+    id: string;
+    source: string;
+    name: string;
+    description: string;
+    trigger: string;
+};
+/**
+ * Publish `session.unbound` onto the runtime hook bus.
+ *
+ * Surfaces call this as they tear down a bound session. The hooks wirer has
+ * already bound the turn.end subscription to this namespace/event, so the single
+ * emit fans out runtime-natively.
+ */
+export declare function emitSessionUnbound(event: SessionUnboundEvent): Promise<void>;
+export default sessionUnboundEvent;
+//# sourceMappingURL=session.unbound.event.descriptor.d.ts.map

package/dist/events/session.unbound.event.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.unbound.event.descriptor.d.ts","sourceRoot":"","sources":["../../src/events/session.unbound.event.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAE5E,oEAAoE;AACpE,eAAO,MAAM,yBAAyB,YAAY,CAAC;AACnD,0EAA0E;AAC1E,eAAO,MAAM,0BAA0B,YAAY,CAAC;AACpD,6EAA6E;AAC7E,eAAO,MAAM,wBAAwB,oBAAoB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,OAAO,EAAE,YAAY,CAAC;CACtB;AAED,eAAO,MAAM,mBAAmB;;;;;;;CAQ9B,CAAC;AAEH;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIlF;AAED,eAAe,mBAAmB,CAAC"}

package/dist/events/session.unbound.event.descriptor.js

@@ -0,0 +1,45 @@
+/**
+ * `session.unbound` — the close-half of `session.bound`.
+ *
+ * Fired by a surface when it RELEASES a previously bound session — e.g. the MCP
+ * stdio/HTTP transport closing. A runtime-native `runtime/event` on the SAME
+ * publish/subscribe machinery as `session.bound`, so a single emit propagates to
+ * every interested slice with NO per-harness code.
+ *
+ * Subscribers (each a `runtime/subscription`, wired generically by the hooks wirer):
+ *   - `awareness.hooks.on-session-unbound` (awareness) — emits a `turn.end`
+ *     awareness event (the close-half of session.bound → turn.start).
+ *
+ * Deliberately does NOT clear the session registry binding: the surface is tearing
+ * down, and a late reader resolving the just-ended session id is harmless and
+ * preferable to racing a clear against in-flight shutdown work.
+ */
+import { createRuntimeAsset } from '@vibesdotdev/kernel';
+/** Hook-bus namespace the wirer derives from the event `source`. */
+export const SESSION_UNBOUND_NAMESPACE = 'session';
+/** Hook-bus event name the wirer derives from the trailing id segment. */
+export const SESSION_UNBOUND_EVENT_NAME = 'unbound';
+/** Runtime/event descriptor id (subscriptions reference this in `event`). */
+export const SESSION_UNBOUND_EVENT_ID = 'session.unbound';
+export const sessionUnboundEvent = createRuntimeAsset({
+    kind: 'runtime/event',
+    id: SESSION_UNBOUND_EVENT_ID,
+    source: SESSION_UNBOUND_NAMESPACE,
+    name: 'Session Unbound',
+    description: 'Emitted when a surface releases a bound session (e.g. transport close). Close-half lifecycle event consumed by the awareness turn.end subscription.',
+    trigger: 'custom'
+});
+/**
+ * Publish `session.unbound` onto the runtime hook bus.
+ *
+ * Surfaces call this as they tear down a bound session. The hooks wirer has
+ * already bound the turn.end subscription to this namespace/event, so the single
+ * emit fans out runtime-natively.
+ */
+export async function emitSessionUnbound(event) {
+    await event.runtime
+        .hooks(SESSION_UNBOUND_NAMESPACE)
+        .emit(SESSION_UNBOUND_EVENT_NAME, event);
+}
+export default sessionUnboundEvent;
+//# sourceMappingURL=session.unbound.event.descriptor.js.map

package/dist/events/session.unbound.event.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.unbound.event.descriptor.js","sourceRoot":"","sources":["../../src/events/session.unbound.event.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,kBAAkB,EAAqB,MAAM,qBAAqB,CAAC;AAE5E,oEAAoE;AACpE,MAAM,CAAC,MAAM,yBAAyB,GAAG,SAAS,CAAC;AACnD,0EAA0E;AAC1E,MAAM,CAAC,MAAM,0BAA0B,GAAG,SAAS,CAAC;AACpD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,wBAAwB,GAAG,iBAAiB,CAAC;AAoB1D,MAAM,CAAC,MAAM,mBAAmB,GAAG,kBAAkB,CAAC;IACrD,IAAI,EAAE,eAAe;IACrB,EAAE,EAAE,wBAAwB;IAC5B,MAAM,EAAE,yBAAyB;IACjC,IAAI,EAAE,iBAAiB;IACvB,WAAW,EACV,qJAAqJ;IACtJ,OAAO,EAAE,QAAQ;CACjB,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,KAA0B;IAClE,MAAM,KAAK,CAAC,OAAO;SACjB,KAAK,CAAwD,yBAAyB,CAAC;SACvF,IAAI,CAAC,0BAA0B,EAAE,KAAK,CAAC,CAAC;AAC3C,CAAC;AAED,eAAe,mBAAmB,CAAC"}

package/dist/helper.d.ts

@@ -0,0 +1,15 @@
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import type { SessionManager } from './manager/index.ts';
+/**
+ * Resolve the root's canonical `SessionManager` through the runtime that owns
+ * it (`runtime.context('session/manager')`). A runtime without the session
+ * plugin is refused typed (`SESSION_MANAGER_UNAVAILABLE`).
+ *
+ * ```ts
+ * import { getVibesSessionManagerAsync } from '@vibesdotdev/session';
+ * const sessionManager = await getVibesSessionManagerAsync(runtime);
+ * const session = await sessionManager.createSession({ title: 'My Session', ownerParticipant });
+ * ```
+ */
+export declare function getVibesSessionManagerAsync(runtime: VibesRuntime): Promise<SessionManager>;
+//# sourceMappingURL=helper.d.ts.map

package/dist/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAWhG"}

package/dist/helper.js

@@ -0,0 +1,23 @@
+import { getVibesClient } from '@vibesdotdev/kernel/client';
+import { assertSessionRuntime } from "./client.js";
+import { createSessionToolError } from "./mcp/utils/participant.js";
+/**
+ * Resolve the root's canonical `SessionManager` through the runtime that owns
+ * it (`runtime.context('session/manager')`). A runtime without the session
+ * plugin is refused typed (`SESSION_MANAGER_UNAVAILABLE`).
+ *
+ * ```ts
+ * import { getVibesSessionManagerAsync } from '@vibesdotdev/session';
+ * const sessionManager = await getVibesSessionManagerAsync(runtime);
+ * const session = await sessionManager.createSession({ title: 'My Session', ownerParticipant });
+ * ```
+ */
+export async function getVibesSessionManagerAsync(runtime) {
+    assertSessionRuntime(runtime);
+    if (!runtime.hasContext('session/manager')) {
+        throw createSessionToolError('SESSION_MANAGER_UNAVAILABLE', 'The runtime has no session/manager context.', 'Ensure the session plugin is registered before using session tools.');
+    }
+    const client = await getVibesClient('session', runtime);
+    return client.getManager();
+}
+//# sourceMappingURL=helper.js.map

package/dist/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAsB,MAAM,aAAa,CAAC;AAEvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAGpE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAAC,OAAqB;IACtE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC9B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE,CAAC;QAC5C,MAAM,sBAAsB,CAC3B,6BAA6B,EAC7B,6CAA6C,EAC7C,qEAAqE,CACrE,CAAC;IACH,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,cAAc,CAAgB,SAAS,EAAE,OAAO,CAAC,CAAC;IACvE,OAAO,MAAM,CAAC,UAAU,EAAE,CAAC;AAC5B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Dev Session Management
+ */
+export { SessionClient } from './client.ts';
+export { SessionManager } from './manager/index.ts';
+export { getVibesSessionManagerAsync } from './helper.ts';
+/**
+ * Session Cockpit (D-063) — canonical paginated projection for the participatory cockpit.
+ */
+export { buildSessionCockpitPage, projectSessionCockpitPage, encodeCockpitCursor, decodeCockpitCursor } from './cockpit/build-state.ts';
+export type { BuildSessionCockpitPageOptions, CockpitPageProjectionInputs, CockpitProjectionResolvers, CockpitParticipantProfile, CockpitCursor } from './cockpit/build-state.ts';
+/**
+ * Session Cockpit (D-054) — canonical participant resolver (resolve-first / mint-once / link).
+ */
+export { getOrCreateWebParticipant, resolveOrCreateParticipantByLink } from './cockpit/resolve-participant.ts';
+export type { WebAuthedIdentity, ParticipantLinkInput } from './cockpit/resolve-participant.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,OAAO,EACN,uBAAuB,EACvB,yBAAyB,EACzB,mBAAmB,EACnB,mBAAmB,EACnB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACX,8BAA8B,EAC9B,2BAA2B,EAC3B,0BAA0B,EAC1B,yBAAyB,EACzB,aAAa,EACb,MAAM,0BAA0B,CAAC;AAElC;;GAEG;AACH,OAAO,EACN,yBAAyB,EACzB,gCAAgC,EAChC,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * Dev Session Management
+ */
+export { SessionClient } from "./client.js";
+export { SessionManager } from "./manager/index.js";
+export { getVibesSessionManagerAsync } from "./helper.js";
+/**
+ * Session Cockpit (D-063) — canonical paginated projection for the participatory cockpit.
+ */
+export { buildSessionCockpitPage, projectSessionCockpitPage, encodeCockpitCursor, decodeCockpitCursor } from "./cockpit/build-state.js";
+/**
+ * Session Cockpit (D-054) — canonical participant resolver (resolve-first / mint-once / link).
+ */
+export { getOrCreateWebParticipant, resolveOrCreateParticipantByLink } from "./cockpit/resolve-participant.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE1D;;GAEG;AACH,OAAO,EACN,uBAAuB,EACvB,yBAAyB,EACzB,mBAAmB,EACnB,mBAAmB,EACnB,MAAM,0BAA0B,CAAC;AASlC;;GAEG;AACH,OAAO,EACN,yBAAyB,EACzB,gCAAgC,EAChC,MAAM,kCAAkC,CAAC"}

package/dist/knowledge-source/vibes.descriptor.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    id: string;
+    kind: "knowledge/expert-session-source";
+    name: string;
+    description: string;
+    hardware: string[];
+    enabled: true;
+};
+export default _default;
+//# sourceMappingURL=vibes.descriptor.d.ts.map

package/dist/knowledge-source/vibes.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibes.descriptor.d.ts","sourceRoot":"","sources":["../../src/knowledge-source/vibes.descriptor.ts"],"names":[],"mappings":";;;;;;;;AAEA,wBAOG"}

package/dist/knowledge-source/vibes.descriptor.js

@@ -0,0 +1,10 @@
+import { createRuntimeAsset } from '@vibesdotdev/kernel/factory';
+export default createRuntimeAsset({
+    id: 'vibes',
+    kind: 'knowledge/expert-session-source',
+    name: 'Vibes Session Training Source',
+    description: 'Session, todo, scratchpad, message and scoped tool-use training data',
+    hardware: ['consumer'],
+    enabled: true
+});
+//# sourceMappingURL=vibes.descriptor.js.map

package/dist/knowledge-source/vibes.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibes.descriptor.js","sourceRoot":"","sources":["../../src/knowledge-source/vibes.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEjE,eAAe,kBAAkB,CAAC;IACjC,EAAE,EAAE,OAAO;IACX,IAAI,EAAE,iCAAiC;IACvC,IAAI,EAAE,+BAA+B;IACrC,WAAW,EAAE,sEAAsE;IACnF,QAAQ,EAAE,CAAC,UAAU,CAAC;IACtB,OAAO,EAAE,IAAI;CACb,CAAC,CAAC"}

package/dist/knowledge-source/vibes.impl.consumer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Vibes Session Source Adapter
+ *
+ * Loads training data from vibes sessions (local SQLite + optional cloud API).
+ * Primary data source for expert model training.
+ *
+ * Data sources:
+ * - Sessions with metadata, tags, descriptions
+ * - Todos with completion tracking and hierarchies
+ * - Scratchpad entries with structured notes
+ * - Inter-participant messages
+ * - File access patterns from external tracking
+ * - Tool use logs (tool calls, results, patterns)
+ *
+ * Quality heuristics:
+ * - Archived sessions with all todos completed = high quality (successful runs)
+ * - Sessions with many completed todos = good signal
+ * - Sessions with scratchpad documentation = well-documented work
+ */
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import type { SessionSourceData, SessionSourceConfig, ExpertSessionSourceStats } from '@vibesdotdev/knowledge/expert/session-source';
+/**
+ * Load vibes session data for training
+ */
+export declare function loadVibesSessionData(runtime: VibesRuntime, config?: Partial<SessionSourceConfig>): Promise<SessionSourceData[]>;
+/**
+ * Load ALL vibes session data for training
+ * Helper for "train on all my data" use case
+ */
+export declare function loadAllVibesData(runtime: VibesRuntime): Promise<SessionSourceData[]>;
+/**
+ * Load only high-quality sessions (archived with completed todos)
+ * Best for training data when quality > quantity
+ */
+export declare function loadHighQualitySessions(runtime: VibesRuntime, minQualityScore?: number): Promise<SessionSourceData[]>;
+/**
+ * Get statistics about available session data
+ */
+export declare function getVibesSessionStats(runtime: VibesRuntime, config?: Partial<SessionSourceConfig>): Promise<ExpertSessionSourceStats>;
+declare const vibesSessionSource: {
+    loadVibesSessionData: typeof loadVibesSessionData;
+    loadAllVibesData: typeof loadAllVibesData;
+    loadHighQualitySessions: typeof loadHighQualitySessions;
+    getVibesSessionStats: typeof getVibesSessionStats;
+};
+export default vibesSessionSource;
+//# sourceMappingURL=vibes.impl.consumer.d.ts.map

package/dist/knowledge-source/vibes.impl.consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vibes.impl.consumer.d.ts","sourceRoot":"","sources":["../../src/knowledge-source/vibes.impl.consumer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,KAAK,EAAqB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAG3E,OAAO,KAAK,EACX,iBAAiB,EACjB,mBAAmB,EAOnB,wBAAwB,EACxB,MAAM,8CAA8C,CAAC;AA4OtD;;GAEG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACvC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA+L9B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAQpF;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC5C,OAAO,EAAE,YAAY,EACrB,eAAe,SAAM,GACnB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAG9B;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACvC,OAAO,CAAC,wBAAwB,CAAC,CAyCnC;AAED,QAAA,MAAM,kBAAkB;;;;;CAA4F,CAAC;AACrH,eAAe,kBAAkB,CAAC"}