@makinbakin/sdk 0.0.1-rc.26 → 0.0.1-rc.28

package/_internal/app/hooks/use-history-back.d.ts

@@ -1 +1,5 @@
-export declare function useHistoryBack(fallbackTo: string): () => void;
+/**
+ * @deprecated Import `useHistoryBack` from `@makinbakin/sdk/navigation`.
+ * This module remains as a compatibility adapter for existing consumers.
+ */
+export { useHistoryBack } from '@makinbakin/sdk/navigation';

package/_internal/app/hooks/use-json-fetch.d.ts

@@ -8,6 +8,15 @@ export interface UseJsonFetchResult<T> {
     /** Re-run the fetch (e.g. after a mutation). */
     refresh: () => void;
 }
+export interface UseJsonFetchOptions extends RequestInit {
+    /**
+     * Abort the request after this many milliseconds and report it as a timeout
+     * rather than a silent hang. Endpoints that scan the filesystem or call the
+     * runtime can stall indefinitely; without a deadline the caller shows a
+     * spinner forever.
+     */
+    timeoutMs?: number;
+}
 /**
  * Cancellable JSON GET with the standard `{ data, loading, error, refresh }` lifecycle —
  * the consolidation of the `let cancelled = false` fetch-in-useEffect boilerplate scattered
@@ -16,11 +25,12 @@ export interface UseJsonFetchResult<T> {
  *
  * Pass `url = null` to skip fetching (e.g. until an id is known); `data` resets to null and
  * `loading` is false while skipped. `opts` is read per-request but does NOT re-trigger on its
- * own identity — change `url` or call `refresh()` to re-fetch.
+ * own identity — change `url` or call `refresh()` to re-fetch. Set `opts.timeoutMs` to bound
+ * a request that can hang.
  */
-export declare function useJsonFetch<T>(url: string | null, opts?: RequestInit): UseJsonFetchResult<T>;
+export declare function useJsonFetch<T>(url: string | null, opts?: UseJsonFetchOptions): UseJsonFetchResult<T>;
 /**
  * `useJsonFetch` scoped to a plugin's own API: builds `/api/plugins/<id>/<path>`
  * so components never hand-assemble the prefix. Pass `path = null` to skip.
  */
-export declare function usePluginJsonFetch<T>(pluginId: string, path: string | null, opts?: RequestInit): UseJsonFetchResult<T>;
+export declare function usePluginJsonFetch<T>(pluginId: string, path: string | null, opts?: UseJsonFetchOptions): UseJsonFetchResult<T>;

package/_internal/app/hooks/use-nav-badge.d.ts

@@ -1,4 +1,4 @@
-import { type NavBadge } from '@makinbakin/sdk';
+import type { NavBadge } from '@makinbakin/sdk/types';
 /**
  * Sync a nav item's badge to the value passed each render. Calls
  * `setNavBadge(pluginId, navItemId, badge)` only when the badge's value

package/_internal/app/hooks/use-query-state.d.ts

@@ -1,16 +1,5 @@
 /**
- * Syncs a single string value to a URL query parameter.
- * Returns [value, setValue, pushValue] like useState.
- * - setValue uses router.replace (no history entry) — good for filters, search, view toggles
- * - pushValue uses router.push (creates history entry) — good for opening drawers/modals
- * When value equals defaultValue, the param is removed from the URL.
- * Multiple setter calls in the same tick compose into one navigation.
+ * @deprecated Import URL-backed state from `@makinbakin/sdk/navigation`.
+ * This module remains as a compatibility adapter for existing consumers.
  */
-export declare function useQueryState(key: string, defaultValue?: string): [string, (v: string) => void, (v: string) => void];
-/**
- * Syncs a string[] to a URL query parameter (comma-separated).
- * Returns [values, setValues] like useState.
- * When array is empty, the param is removed from the URL.
- * Composes with other setter calls in the same tick (one navigation).
- */
-export declare function useQueryArrayState(key: string): [string[], (v: string[]) => void];
+export { useQueryArrayState, useQueryState } from '@makinbakin/sdk/navigation';

package/_internal/core/adapters/runtime/channels.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Channel/delivery contract types — a LEAF module (imports only
+ * ./capabilities) so both the runtime contract (concepts.ts) and the
+ * delivery-bridge seam (packages/core/src/delivery/bridge.ts, threaded
+ * through AdapterInitOpts in ../shared.ts) can share the surface without an
+ * import cycle: shared -> bridge -> channels and concepts -> channels.
+ */
+import type { ChannelCapability } from './capabilities';
+export type RuntimeMetadata = Record<string, unknown>;
+export interface ChannelInfo {
+    id: string;
+    platform: string;
+    label: string;
+    capabilities: ChannelCapability[];
+    metadata?: RuntimeMetadata;
+}
+export interface DeliveryResult {
+    deliveries: ApprovalDelivery[];
+}
+export interface NotificationArgs {
+    channels: string[];
+    notification: {
+        severity: 'info' | 'warn' | 'error' | 'success';
+        title: string;
+        body: string;
+        fields?: {
+            label: string;
+            value: string;
+        }[];
+        metadata?: RuntimeMetadata;
+    };
+}
+export interface ChannelMessageArgs {
+    channels: string[];
+    message: {
+        body: string;
+        title?: string;
+        threadId?: string;
+        metadata?: RuntimeMetadata;
+    };
+}
+export interface ContentDeliveryArgs {
+    channels: string[];
+    content: {
+        title: string;
+        body?: string;
+        url?: string;
+        /**
+         * Path files are read from disk (trusted plugin/core callers only). For
+         * `{ kind: 'asset' }` refs, `filename` is the ASSET ID — providers
+         * resolve it through the `assets.resolveServe` hook; an unresolvable id
+         * degrades to a visible omission, never a failed delivery.
+         */
+        files?: Array<{
+            name: string;
+            path: string;
+            contentType?: string;
+        } | {
+            kind: 'asset';
+            filename: string;
+            mimeType?: string;
+        }>;
+        metadata?: RuntimeMetadata;
+    };
+}
+export interface CreateThreadArgs {
+    /** Channel ref the anchor message lives in (provider or provider:target). */
+    channel: string;
+    /** Delivery ref of the message to anchor the thread to (e.g. "message:<id>"). */
+    messageRef?: string;
+    name: string;
+}
+export interface CreatedThread {
+    threadId: string;
+    /**
+     * Provider-addressable channel ref for posting INTO the thread (opaque to
+     * callers — provider target syntax stays inside the adapter).
+     */
+    channelRef: string;
+}
+export interface EditChannelMessageArgs {
+    /** Channel ref the message lives in (provider or provider:target). */
+    channel: string;
+    /** Delivery ref of the message to edit (e.g. "message:<id>"). */
+    messageRef: string;
+    body: string;
+}
+export interface ApprovalOption {
+    id: string;
+    label: string;
+    variant?: 'primary' | 'destructive' | 'neutral';
+}
+export interface ApprovalDelivery {
+    channelId: string;
+    ref: string;
+    renderedAt: string;
+}
+export interface ApprovalPatch {
+    body?: string;
+    options?: ApprovalOption[];
+    expiresAt?: string;
+    context?: RuntimeMetadata;
+}
+export interface ApprovalResponse {
+    selectedOption: string;
+    respondedAt: string;
+    actor: {
+        type: 'agent' | 'human';
+        id: string;
+        displayName?: string;
+    };
+    comment?: string;
+}
+export interface ApprovalRenderResult {
+    deliveries: ApprovalDelivery[];
+}
+export interface ApprovalRenderRef {
+    approvalId: string;
+    deliveries: ApprovalDelivery[];
+}
+export interface CreateApprovalArgs {
+    approvalId: string;
+    channels: string[];
+    request: {
+        title: string;
+        body: string;
+        options: ApprovalOption[];
+        expiresAt?: string;
+        context?: RuntimeMetadata;
+    };
+}
+export interface EditApprovalArgs extends ApprovalRenderRef {
+    patch: ApprovalPatch;
+}
+export interface CancelApprovalArgs extends ApprovalRenderRef {
+    reason?: string;
+}
+export interface ResolveApprovalArgs extends ApprovalRenderRef {
+    response: ApprovalResponse;
+}
+export interface ApprovalResolveEvent {
+    approvalId: string;
+    response: ApprovalResponse;
+    channelId: string;
+}
+export interface DurableApprovalRecord {
+    approvalId: string;
+    owner: {
+        workflowId: string;
+        runId: string;
+        stepId: string;
+        taskId?: string;
+    };
+    status: 'pending' | 'approved' | 'rejected' | 'cancelled' | 'expired';
+    request: CreateApprovalArgs['request'];
+    deliveries: ApprovalDelivery[];
+    response?: ApprovalResponse;
+    createdAt: string;
+    updatedAt: string;
+    resolvedAt?: string;
+}
+/** An inbound attachment already materialized to a LOCAL file by the provider. */
+export interface InboundChannelAttachment {
+    name: string;
+    path: string;
+    contentType?: string;
+    size?: number;
+}
+/**
+ * A human message arriving FROM a channel (#669 Phase B). The provider has
+ * already applied its gating (allowlists, mention requirements) — a handler
+ * receiving this may treat the sender as authorized. `channelRef` is
+ * provider-qualified and directly usable as a send target for the reply.
+ */
+export interface InboundChannelMessage {
+    platform: string;
+    channelRef: string;
+    authorId: string;
+    authorName?: string;
+    text: string;
+    attachments?: InboundChannelAttachment[];
+    /** Provider message ref (e.g. "message:<id>"). */
+    messageRef: string;
+    /**
+     * Structured control command (e.g. a slash command) instead of chat text —
+     * when present, `text` is empty and consumers act on the verb ("new-chat"
+     * unbinds the channel's chat so the next message starts fresh). The
+     * provider has already acked the command UI-side.
+     */
+    command?: {
+        name: string;
+    };
+}
+/**
+ * The full channel surface a delivering runtime exposes (see
+ * `AgentRuntimeAdapter.channels` for the capability semantics — the member
+ * is OPTIONAL there; this type is the shape when present).
+ */
+export interface RuntimeChannelSurface {
+    list(): Promise<ChannelInfo[]>;
+    sendNotification(args: NotificationArgs): Promise<DeliveryResult>;
+    sendMessage(args: ChannelMessageArgs): Promise<DeliveryResult>;
+    deliverContent(args: ContentDeliveryArgs): Promise<DeliveryResult>;
+    createApproval(args: CreateApprovalArgs): Promise<ApprovalRenderResult>;
+    editApproval(args: EditApprovalArgs): Promise<ApprovalRenderResult>;
+    cancelApproval(args: CancelApprovalArgs): Promise<void>;
+    resolveApproval(args: ResolveApprovalArgs): Promise<void>;
+    subscribeApprovalResponses(handler: (event: ApprovalResolveEvent) => void): () => void;
+    /**
+     * Optional threading/editing capabilities. Adapters for providers without
+     * threads or message editing omit them; callers MUST feature-detect and
+     * fall back to flat channel messages — never error on absence.
+     */
+    createThread?(args: CreateThreadArgs): Promise<CreatedThread | null>;
+    editMessage?(args: EditChannelMessageArgs): Promise<void>;
+    /**
+     * OPTIONAL inbound stream (#669 Phase B): human messages from the channel
+     * platform, pre-gated by the provider (allowlists fail closed; guild
+     * messages mention-gated). Runtimes that handle inbound themselves
+     * (OpenClaw) OMIT this member — consumers feature-detect.
+     */
+    subscribeInboundMessages?(handler: (message: InboundChannelMessage) => void): () => void;
+    /**
+     * OPTIONAL ephemeral typing/activity signal (#669 Phase B, D10). Providers
+     * without the concept omit it; callers feature-detect and repeat while
+     * work runs (platform typing states expire — Discord's after ~10s).
+     */
+    sendTyping?(args: {
+        channel: string;
+    }): Promise<void>;
+}

package/_internal/core/adapters/runtime/concepts.d.ts

@@ -1,8 +1,8 @@
-import type { AdapterInitOpts, MessageUsage, RuntimeExecToolProvider, Unsubscribe } from '../shared';
+import type { AdapterInitOpts, MessageUsage, RuntimeExecToolProvider } from '../shared';
 import type { ActivityClass } from '@makinbakin/sdk/types';
-import type { ChannelCapability } from './capabilities';
+import type { RuntimeChannelSurface, RuntimeMetadata } from './channels';
 export type { MessageUsage } from '../shared';
-export type RuntimeMetadata = Record<string, unknown>;
+export type { RuntimeMetadata } from './channels';
 export interface RuntimeAgent {
     id: string;
     name: string;
@@ -243,152 +243,7 @@ export type ChatChunk =
     content?: string;
     data?: RuntimeMetadata;
 };
-export interface ChannelInfo {
-    id: string;
-    platform: string;
-    label: string;
-    capabilities: ChannelCapability[];
-    metadata?: RuntimeMetadata;
-}
-export interface DeliveryResult {
-    deliveries: ApprovalDelivery[];
-}
-export interface NotificationArgs {
-    channels: string[];
-    notification: {
-        severity: 'info' | 'warn' | 'error' | 'success';
-        title: string;
-        body: string;
-        fields?: {
-            label: string;
-            value: string;
-        }[];
-        metadata?: RuntimeMetadata;
-    };
-}
-export interface ChannelMessageArgs {
-    channels: string[];
-    message: {
-        body: string;
-        title?: string;
-        threadId?: string;
-        metadata?: RuntimeMetadata;
-    };
-}
-export interface ContentDeliveryArgs {
-    channels: string[];
-    content: {
-        title: string;
-        body?: string;
-        url?: string;
-        files?: Array<{
-            name: string;
-            path: string;
-            contentType?: string;
-        } | {
-            kind: 'asset';
-            filename: string;
-            mimeType?: string;
-        }>;
-        metadata?: RuntimeMetadata;
-    };
-}
-export interface CreateThreadArgs {
-    /** Channel ref the anchor message lives in (provider or provider:target). */
-    channel: string;
-    /** Delivery ref of the message to anchor the thread to (e.g. "message:<id>"). */
-    messageRef?: string;
-    name: string;
-}
-export interface CreatedThread {
-    threadId: string;
-    /**
-     * Provider-addressable channel ref for posting INTO the thread (opaque to
-     * callers — provider target syntax stays inside the adapter).
-     */
-    channelRef: string;
-}
-export interface EditChannelMessageArgs {
-    /** Channel ref the message lives in (provider or provider:target). */
-    channel: string;
-    /** Delivery ref of the message to edit (e.g. "message:<id>"). */
-    messageRef: string;
-    body: string;
-}
-export interface ApprovalOption {
-    id: string;
-    label: string;
-    variant?: 'primary' | 'destructive' | 'neutral';
-}
-export interface ApprovalDelivery {
-    channelId: string;
-    ref: string;
-    renderedAt: string;
-}
-export interface ApprovalPatch {
-    body?: string;
-    options?: ApprovalOption[];
-    expiresAt?: string;
-    context?: RuntimeMetadata;
-}
-export interface ApprovalResponse {
-    selectedOption: string;
-    respondedAt: string;
-    actor: {
-        type: 'agent' | 'human';
-        id: string;
-        displayName?: string;
-    };
-    comment?: string;
-}
-export interface ApprovalRenderResult {
-    deliveries: ApprovalDelivery[];
-}
-export interface ApprovalRenderRef {
-    approvalId: string;
-    deliveries: ApprovalDelivery[];
-}
-export interface CreateApprovalArgs {
-    approvalId: string;
-    channels: string[];
-    request: {
-        title: string;
-        body: string;
-        options: ApprovalOption[];
-        expiresAt?: string;
-        context?: RuntimeMetadata;
-    };
-}
-export interface EditApprovalArgs extends ApprovalRenderRef {
-    patch: ApprovalPatch;
-}
-export interface CancelApprovalArgs extends ApprovalRenderRef {
-    reason?: string;
-}
-export interface ResolveApprovalArgs extends ApprovalRenderRef {
-    response: ApprovalResponse;
-}
-export interface ApprovalResolveEvent {
-    approvalId: string;
-    response: ApprovalResponse;
-    channelId: string;
-}
-export interface DurableApprovalRecord {
-    approvalId: string;
-    owner: {
-        workflowId: string;
-        runId: string;
-        stepId: string;
-        taskId?: string;
-    };
-    status: 'pending' | 'approved' | 'rejected' | 'cancelled' | 'expired';
-    request: CreateApprovalArgs['request'];
-    deliveries: ApprovalDelivery[];
-    response?: ApprovalResponse;
-    createdAt: string;
-    updatedAt: string;
-    resolvedAt?: string;
-}
+export type { ChannelInfo, DeliveryResult, NotificationArgs, ChannelMessageArgs, ContentDeliveryArgs, CreateThreadArgs, CreatedThread, EditChannelMessageArgs, ApprovalOption, ApprovalDelivery, ApprovalPatch, ApprovalResponse, ApprovalRenderResult, ApprovalRenderRef, CreateApprovalArgs, EditApprovalArgs, CancelApprovalArgs, ResolveApprovalArgs, ApprovalResolveEvent, DurableApprovalRecord, InboundChannelAttachment, InboundChannelMessage, RuntimeChannelSurface, } from './channels';
 export interface RuntimeSkill {
     name: string;
     path?: string;
@@ -404,6 +259,31 @@ export interface RuntimeSession {
     updatedAt?: string;
     metadata?: RuntimeMetadata;
 }
+/**
+ * A session's context reading (#737) — runtime truth only, read AT REST.
+ * Null-honesty is the contract: `tokens: null` means honestly unknown
+ * (e.g. immediately after a compaction before the next assistant reply,
+ * or a stale store entry) — NEVER a stale or derived number; billing
+ * aggregates (which sum across a turn's internal tool-loop requests) are
+ * banned as a source. `compactionThreshold: null` when the runtime owns
+ * compaction opaquely (e.g. codex-native).
+ */
+export interface RuntimeSessionContextStats {
+    /** Current context tokens; null = honestly unknown. */
+    tokens: number | null;
+    /** The model's context window; null when unknown. */
+    contextWindow: number | null;
+    /** Auto-compaction trigger point in tokens; null when unknowable. */
+    compactionThreshold: number | null;
+    /** Last compaction, when detectable from durable runtime records. */
+    lastCompaction?: {
+        at?: string;
+        tokensBefore?: number;
+        reason?: string;
+    };
+    /** Model the stats describe (`provider/modelId` form), when known. */
+    model?: string;
+}
 export interface RuntimeSessionStoreStats {
     agentId: string;
     /** Live entries in the runtime's session store for this agent. */
@@ -896,24 +776,7 @@ export interface AgentRuntimeAdapter {
      * honestly: empty channel lists, log-only alerts, UI-only approval gates.
      * `capabilities().delivery.mode` reports the same fact declaratively.
      */
-    channels?: {
-        list(): Promise<ChannelInfo[]>;
-        sendNotification(args: NotificationArgs): Promise<DeliveryResult>;
-        sendMessage(args: ChannelMessageArgs): Promise<DeliveryResult>;
-        deliverContent(args: ContentDeliveryArgs): Promise<DeliveryResult>;
-        createApproval(args: CreateApprovalArgs): Promise<ApprovalRenderResult>;
-        editApproval(args: EditApprovalArgs): Promise<ApprovalRenderResult>;
-        cancelApproval(args: CancelApprovalArgs): Promise<void>;
-        resolveApproval(args: ResolveApprovalArgs): Promise<void>;
-        subscribeApprovalResponses(handler: (event: ApprovalResolveEvent) => void): Unsubscribe;
-        /**
-         * Optional threading/editing capabilities. Adapters for providers without
-         * threads or message editing omit them; callers MUST feature-detect and
-         * fall back to flat channel messages — never error on absence.
-         */
-        createThread?(args: CreateThreadArgs): Promise<CreatedThread | null>;
-        editMessage?(args: EditChannelMessageArgs): Promise<void>;
-    };
+    channels?: RuntimeChannelSurface;
     skills: {
         list(agentId?: string): Promise<RuntimeSkill[]>;
         get(name: string, agentId?: string): Promise<RuntimeSkill | null>;
@@ -929,6 +792,18 @@ export interface AgentRuntimeAdapter {
          * as "stats unavailable" — skip, never error.
          */
         storeStats?(): Promise<RuntimeSessionStoreStats[]>;
+        /**
+         * Context stats for one Bakin thread's session (#737), read AT REST —
+         * no gateway calls, no turn, no session mutation, no thread locks.
+         * Keyed on {agentId, threadId} because the thread→session mapping is
+         * adapter-private on every runtime. Optional: runtimes that cannot
+         * answer omit the member; callers treat absence as unavailable —
+         * skip, never error. Null = no session / nothing honest to report.
+         */
+        contextStats?(opts: {
+            agentId: string;
+            threadId: string;
+        }): Promise<RuntimeSessionContextStats | null>;
     };
     memory: {
         listTiers(): Promise<RuntimeMemoryTier[]>;

package/_internal/core/adapters/runtime/index.d.ts

@@ -6,5 +6,6 @@ export { hasChannelCapability } from './capabilities';
 export { RuntimeError, RuntimeTurnError } from './errors';
 export type { RuntimeErrorKind, RuntimeErrorOptions, RuntimeProviderInfo, RuntimeTurnDiagnosis, RuntimeTurnFailureReason, } from './errors';
 export { getRuntimeMainAgent, getRuntimeMainAgentId, getRuntimeMainAgentName, selectRuntimeMainAgent, } from './helpers';
-export type { AgentRuntimeAdapter, ApprovalDelivery, ApprovalOption, ApprovalPatch, ApprovalRenderRef, ApprovalRenderResult, ApprovalResolveEvent, ApprovalResponse, CancelApprovalArgs, ChannelInfo, ChannelMessageArgs, ChatChunk, ChatTextFormat, ContentDeliveryArgs, CreateApprovalArgs, CreateCronJobInput, CreateRuntimeAgentInput, CronJob, CronRun, DeliveryResult, DurableApprovalRecord, EditApprovalArgs, MessageArgs, MessageAttachment, MessageResult, MessageUsage, NotificationArgs, ResolveApprovalArgs, RuntimeAgent, RuntimeAllowlistPatch, RuntimeToolActivity, RuntimeAvailableModel, RuntimeCapabilities, CapabilityMode, ToolAccessStyle, RuntimeToolAccess, ToolAccessProvisioningStatus, RuntimeCredentialStatus, RuntimeRoutingPolicy, RuntimeRoutingSupport, CapabilitySet, RuntimeImageBackground, RuntimeImageEditInput, RuntimeImageFile, RuntimeImageGenerateInput, RuntimeImageGenerationResult, RuntimeImageOutputFormat, RuntimeImageProvider, RuntimeImageProviderCapabilities, RuntimeImagesAccess, RuntimeExtensionInfo, RuntimeExtensionsAccess, RuntimeMemoryEntry, RuntimeMemoryEntryStat, RuntimeMemoryPathMatch, RuntimeMemoryReadRange, RuntimeMemorySearchResult, RuntimeMemoryTier, RuntimeMessageToolPolicy, RuntimeMessageToolsMode, RuntimeMetadata, RawCronSnapshot, RuntimeSession, RuntimeSessionStoreStats, RuntimeSkill, UpdateCronJobInput, UpdateRuntimeAgentInput, WorkspaceFile, WorkspaceFileStat, } from './concepts';
+export type { AgentRuntimeAdapter, ApprovalDelivery, ApprovalOption, ApprovalPatch, ApprovalRenderRef, ApprovalRenderResult, ApprovalResolveEvent, ApprovalResponse, CancelApprovalArgs, ChannelInfo, ChannelMessageArgs, ChatChunk, ChatTextFormat, ContentDeliveryArgs, CreateApprovalArgs, CreateThreadArgs, CreatedThread, CreateCronJobInput, CreateRuntimeAgentInput, CronJob, CronRun, DeliveryResult, DurableApprovalRecord, EditApprovalArgs, EditChannelMessageArgs, InboundChannelAttachment, InboundChannelMessage, MessageArgs, MessageAttachment, MessageResult, MessageUsage, NotificationArgs, ResolveApprovalArgs, RuntimeAgent, RuntimeAllowlistPatch, RuntimeToolActivity, RuntimeAvailableModel, RuntimeCapabilities, CapabilityMode, ToolAccessStyle, RuntimeToolAccess, ToolAccessProvisioningStatus, RuntimeCredentialStatus, RuntimeRoutingPolicy, RuntimeRoutingSupport, CapabilitySet, RuntimeImageBackground, RuntimeImageEditInput, RuntimeImageFile, RuntimeImageGenerateInput, RuntimeImageGenerationResult, RuntimeImageOutputFormat, RuntimeImageProvider, RuntimeImageProviderCapabilities, RuntimeImagesAccess, RuntimeExtensionInfo, RuntimeExtensionsAccess, RuntimeMemoryEntry, RuntimeMemoryEntryStat, RuntimeMemoryPathMatch, RuntimeMemoryReadRange, RuntimeMemorySearchResult, RuntimeMemoryTier, RuntimeMessageToolPolicy, RuntimeMessageToolsMode, RuntimeMetadata, RawCronSnapshot, RuntimeSession, RuntimeSessionStoreStats, RuntimeSessionContextStats, RuntimeSkill, UpdateCronJobInput, UpdateRuntimeAgentInput, WorkspaceFile, WorkspaceFileStat, } from './concepts';
 export { RUNTIME_MEDIA_URI_SCHEME, DEFAULT_OVERSIZED_OUTPUT_BYTES } from './concepts';
+export { isSafeSkillFilePath, isExecutableSkillFile, readSkillTree, SKILL_SIDECAR_NAMES } from './skill-files';

package/_internal/core/adapters/runtime/skill-files.d.ts

@@ -0,0 +1,12 @@
+/** Relative path inside a skill dir: no absolute, no backslash, no `..`/empty segments. */
+export declare function isSafeSkillFilePath(path: string): boolean;
+/** Metadata sidecars — never part of a skill's file map. */
+export declare const SKILL_SIDECAR_NAMES: Set<string>;
+/** Scripts get the executable bit at projection: shebang or a script extension. */
+export declare function isExecutableSkillFile(path: string, content: string): boolean;
+/**
+ * Read a skill directory into a relative-path→content map, skipping
+ * symlinks and the metadata sidecars (`.installedBy`/`.userEdited`) at any
+ * depth. Unreadable roots read as empty.
+ */
+export declare function readSkillTree(root: string): Record<string, string>;

package/_internal/core/adapters/shared.d.ts

@@ -1,4 +1,5 @@
 import type { ActivityClass } from '@makinbakin/sdk/types';
+import type { ChannelBridge } from '../delivery/bridge';
 export type Unsubscribe = () => void;
 export interface AdapterLogger {
     debug(message: string, data?: unknown): void;
@@ -108,6 +109,14 @@ export interface RuntimeExecToolProvider {
 }
 export interface AdapterInitOpts {
     contentDir: string;
+    /**
+     * Optional runtime-neutral channel bridge (issue #669). Runtimes without a
+     * native delivery layer (Pi) expose `runtime.channels` by delegating to
+     * this handle when `isConfigured()`; natively-delivering runtimes ignore
+     * it. This is a HANDLE only — the server owns `boot()`/`shutdown()`;
+     * adapters never connect transports.
+     */
+    channelBridge?: ChannelBridge;
     settings?: Record<string, unknown>;
     /**
      * LIVE view of the adapter-private settings bag. `settings` is a boot-time
@@ -138,6 +147,8 @@ export interface AdapterInitOpts {
      * (Pi) ignore it.
      */
     bakinMcpBaseUrl?: string;
+    /** Host-issued credential scoped to a single agent; never log this value. */
+    getMcpCredential?: (agentId: string) => string;
 }
 export interface AdapterVersionInfo {
     readonly name: string;

package/_internal/core/delivery/bridge.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Runtime-neutral channel bridge contract (issue #669).
+ *
+ * A ChannelBridge gives a runtime WITHOUT a native channel/delivery layer
+ * (Pi) a `runtime.channels` surface by delegation. The concrete Discord
+ * implementation lives in `src/core/delivery/` — app code; this package only
+ * defines the seam so adapter packages can accept a bridge without importing
+ * app modules (adapters never import `src/`).
+ *
+ * Lifecycle: the HANDLE is threaded through `AdapterInitOpts.channelBridge`
+ * at adapter init (cheap, no I/O); `boot()`/`shutdown()` are called by the
+ * server only — never inside `createAppServices()`, which read-only CLI
+ * paths also call. `isConfigured()` must be side-effect-free and callable
+ * before boot: adapters use it to decide whether to expose `channels` and
+ * whether `capabilities().delivery.mode` reports `'shimmed'` or
+ * `'unavailable'`.
+ */
+import type { RuntimeChannelSurface } from '../adapters/runtime/channels';
+/** The full channel surface, contract-identical to a native adapter's. */
+export type ChannelSurface = RuntimeChannelSurface;
+export interface ChannelBridge {
+    /**
+     * True when non-secret config AND the transport secret are present.
+     * Side-effect-free; the gate for exposing `channels` on an adapter.
+     */
+    isConfigured(): boolean;
+    /** Connect transports. Server-boot only; idempotent. */
+    boot(): Promise<void>;
+    /** Disconnect and release transports. Safe when never booted. */
+    shutdown(): Promise<void>;
+    /**
+     * The delegated channel surface. Only meaningful when `isConfigured()`;
+     * adapters must not expose it otherwise.
+     */
+    channels: ChannelSurface;
+}

package/_internal/core/format.d.ts

@@ -1,5 +1,16 @@
+export interface FormatAgeOptions {
+    /**
+     * Resolve below a minute ("42s ago") instead of flattening to "just now".
+     *
+     * Live-status surfaces need it: on a heartbeat or an activity feed the
+     * difference between five seconds and fifty is the signal, and minute
+     * granularity erases it. Everything under ten seconds still reads
+     * "just now" so a ticking feed does not flicker through 1s/2s/3s.
+     */
+    precise?: boolean;
+}
 /** Human-readable relative time from an ISO timestamp */
-export declare function formatAge(timestamp: string): string;
+export declare function formatAge(timestamp: string, options?: FormatAgeOptions): string;
 /**
  * Human-readable absolute date+time with calendar awareness:
  * "Today 3:45 PM" / "Yesterday 9:02 AM" / "Jan 5 3:45 PM", carrying the year