dsh-run2skill 0.3.1 → 0.5.0-alpha.2

package/lib/contract-vZz7H2_H.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+//#region src/adapters/dsh-remote/contract.ts
+const RUN2SKILL_QUERY_ENDPOINTS = [
+	"observe-summary",
+	"attention",
+	"proposals/list",
+	"summary",
+	"proposals/get",
+	"recent-activity/list",
+	"learning/status",
+	"learning/issues/list",
+	"purge/preview",
+	"purge/status"
+];
+const RUN2SKILL_COMMAND_ENDPOINTS = [
+	"proposals/approve",
+	"proposals/reject",
+	"proposals/retry",
+	"proposals/refresh",
+	"proposals/revise",
+	"coverage/confirm-discard",
+	"learning/request",
+	"learning/issues/retry",
+	"learning/issues/dismiss",
+	"purge/confirm",
+	"purge/retry"
+];
+const queryEndpoints = new Set(RUN2SKILL_QUERY_ENDPOINTS);
+const commandEndpoints = new Set(RUN2SKILL_COMMAND_ENDPOINTS);
+function routeRun2skillEndpoint(endpoint) {
+	if (queryEndpoints.has(endpoint)) return "query";
+	if (commandEndpoints.has(endpoint)) return "command";
+	throw new TypeError(`unknown run2skill endpoint: ${endpoint}`);
+}
+const jsonValue = z.json();
+const queryRequest = z.object({
+	endpoint: z.enum(RUN2SKILL_QUERY_ENDPOINTS),
+	payload: jsonValue
+}).strict();
+const commandRequest = z.object({
+	endpoint: z.enum(RUN2SKILL_COMMAND_ENDPOINTS),
+	payload: jsonValue
+}).strict();
+const rpcResult = z.discriminatedUnion("ok", [z.object({
+	ok: z.literal(true),
+	value: jsonValue
+}).strict(), z.object({
+	ok: z.literal(false),
+	error: z.object({
+		code: z.string().min(1),
+		message: z.string(),
+		details: z.record(z.string(), jsonValue)
+	}).strict()
+}).strict()]);
+function descriptor(method, requestSchema) {
+	const value = {
+		id: `dsh-run2skill#run2skill/${method}`,
+		service: "run2skillRemote",
+		namespace: "run2skill",
+		method,
+		invocation: { kind: "direct" },
+		parameters: [{
+			name: "request",
+			wire: "request",
+			source: "json",
+			codec: {
+				mode: "strict",
+				typeSymbol: method === "query" ? "Run2skillQueryRequest" : "Run2skillCommandRequest",
+				create: () => requestSchema
+			}
+		}],
+		cancellation: { parameter: "signal" },
+		result: {
+			mode: "strict",
+			typeSymbol: "Run2skillRpcResult",
+			create: () => rpcResult
+		}
+	};
+	return Object.freeze(value);
+}
+const RUN2SKILL_REMOTE_DESCRIPTORS = Object.freeze([descriptor("query", queryRequest), descriptor("command", commandRequest)]);
+const RUN2SKILL_REMOTE = Object.freeze({
+	package: "dsh-run2skill",
+	descriptors: RUN2SKILL_REMOTE_DESCRIPTORS
+});
+//#endregion
+export { RUN2SKILL_REMOTE_DESCRIPTORS as n, routeRun2skillEndpoint as r, RUN2SKILL_REMOTE as t };

package/lib/index.d.ts

@@ -4841,12 +4841,24 @@ interface SessionPersistenceSnapshot {
   readonly header: DshSessionHeader;
   readonly revision: string;
 }
-interface SessionPersistencePort {
-  listSnapshots(signal?: AbortSignal): Promise<readonly SessionPersistenceSnapshot[]>;
-  readFrom(sessionId: string, fromSeq: number, signal?: AbortSignal): Promise<{
-    readonly meta: DshSessionHeader;
+interface DshSessionReadHandlePort {
+  readonly header: DshSessionHeader;
+  read(offset?: number, length?: number, options?: {
+    readonly signal?: AbortSignal;
+  }): Promise<{
+    readonly eventState: 'detached' | 'shared-frozen';
     readonly events: readonly DshSessionEvent[];
   }>;
+  close(): Promise<void>;
+}
+/** DSH 0.1.3-alpha.2 persistence service exposed as ctx.sessionPersistence. */
+interface DshSessionPersistencePort {
+  list(options?: {
+    readonly signal?: AbortSignal;
+  }): Promise<readonly SessionPersistenceSnapshot[]>;
+  open(sessionId: string, access: 'read', options?: {
+    readonly signal?: AbortSignal;
+  }): Promise<DshSessionReadHandlePort>;
 }
 //#endregion
 //#region src/adapters/dsh-filesystem/context-filesystem.d.ts
@@ -4855,28 +4867,6 @@ interface DshContextFileSystemTarget {
   readonly displayPath: string;
 }
 //#endregion
-//#region src/adapters/dsh-connection/observe-summary-rpc.d.ts
-type ObserveRpcError = {
-  readonly code: string;
-  readonly message: string;
-  readonly details: Record<string, unknown>;
-};
-type ObserveRpcResult<T> = {
-  readonly ok: true;
-  readonly value: T;
-} | {
-  readonly ok: false;
-  readonly error: ObserveRpcError;
-};
-type ObserveSummaryRpcHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<ObserveRpcResult<unknown>>;
-interface ObserveSummaryHostConnection {
-  readonly rpc: {
-    handle(channel: string, handler: ObserveSummaryRpcHandler, options: {
-      readonly authority: 'loopback';
-    }): () => Promise<void>;
-  };
-}
-//#endregion
 //#region src/application/automatic-learning-policy.d.ts
 interface AutomaticLearningSnapshot {
   readonly automaticLearning: boolean;
@@ -5519,6 +5509,12 @@ interface StockPluginRuntimeProjection {
 interface StockPresetMountProjection {
   readonly presetId: string;
   readonly fiber: StockFiberProjection;
+  readonly key?: object | undefined;
+  readonly tree?: {
+    readonly root: {
+      readonly data: unknown;
+    };
+  } | undefined;
 }
 interface StockPresetMountPort {
   standingMountFor(agentContext: object): StockPresetMountProjection | undefined | Promise<StockPresetMountProjection | undefined>;
@@ -5531,32 +5527,26 @@ interface StockComposedAgentProjection {
     readonly get?: (name: string) => unknown;
   };
 }
-interface StockAgentPresetObservationPort {
-  composedPreset(agentContext: object): string | undefined;
-  resolve(id: string): Promise<{
-    readonly id: string;
-    readonly trust: 'system' | 'user';
-  }>;
-  read(id: string): Promise<string>;
-}
-declare function resolvePinnedStockPresetConfiguration(presets: StockAgentPresetObservationPort, agent: {
-  readonly ctx: object;
-}, expectedDigests?: Readonly<Record<'standard' | 'code', readonly string[]>>): Promise<StockSkillRuntimeConfiguration | undefined>;
 /** Reads the exact stock filesystem fiber mounted for one Agent's joined generation. */
-declare function resolveStockSkillRuntimeConfiguration(mounts: StockPresetMountPort, agent: StockComposedAgentProjection): Promise<StockSkillRuntimeConfiguration | undefined>;
+declare function resolveStockSkillRuntimeConfiguration(mounts: StockPresetMountPort, agent: StockComposedAgentProjection, expectedDigest?: string): Promise<StockSkillRuntimeConfiguration | undefined>;
 //#endregion
-//#region src/adapters/dsh-settings/automatic-learning.d.ts
-interface DshSettingsScope<T> {
-  get(): T;
-  watch(callback: (next: T, previous: T) => void | Promise<void>): () => void;
+//#region src/adapters/dsh-skills/stock-cold-preset.d.ts
+interface StockPresetLease {
+  readonly key: object;
+  [Symbol.asyncDispose](): Promise<void>;
 }
-interface DshSettingsPort {
-  register<T>(namespace: string, schema: z$1<T>, options: {
-    readonly applies: 'live';
-  }): DshSettingsScope<T>;
+interface StockColdPresetRegistry {
+  acquireScope(id: string): Promise<StockPresetLease>;
+}
+//#endregion
+//#region src/adapters/dsh-settings/automatic-learning.d.ts
+interface AutomaticLearningConfig {
+  readonly automaticLearning: {
+    get(): boolean;
+  };
 }
 interface AutomaticLearningSettingsPolicy extends AutomaticLearningPolicyPort {
-  watch(callback: (next: AutomaticLearningSnapshot, previous: AutomaticLearningSnapshot) => void | Promise<void>): () => void;
+  watch(callback: (next: AutomaticLearningSnapshot, previous: AutomaticLearningSnapshot) => void): () => void;
 }
 //#endregion
 //#region src/application/purge/purge-service.d.ts
@@ -5716,20 +5706,21 @@ declare class PublicationTargetSingleFlight {
 //#endregion
 //#region src/host/index.d.ts
 declare const name = "run2skill";
-declare const inject: readonly ["agents", "sessions", "sessionPersistence", "storageDomain", "workspaceRegistry", "connection", "llm", "skills", "settings", "agentPresets", "fs"];
+declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+  automaticLearning: import("@deepseek-ai/schemastery").default<boolean, boolean, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+  automaticLearning: import("@deepseek-ai/schemastery").default<boolean, boolean, "volatile-defined">;
+}>>, "plain">;
+declare const inject: readonly ["agents", "sessions", "sessionPersistence", "storageDomain", "workspaceRegistry", "llm", "skills", "agentPresets", "fs"];
 type Run2skillAgent = object & AgentScopeProjection & Parameters<typeof resolveStockSkillRuntimeConfiguration>[1];
-type Run2skillAgentPresets = Parameters<typeof resolvePinnedStockPresetConfiguration>[0] & {
-  standingKeyFor(id?: string): Promise<object>;
-};
+type Run2skillAgentPresets = StockColdPresetRegistry;
 interface Run2skillHostContext extends Run2skillStorageContext {
   readonly agents: unknown;
   readonly sessions: unknown;
-  readonly sessionPersistence: SessionPersistencePort;
+  readonly sessionPersistence: DshSessionPersistencePort;
   readonly workspaceRegistry: DshWorkspaceRegistryPort;
-  readonly connection: ObserveSummaryHostConnection;
   readonly llm: DshLlmPort;
   readonly skills: DshSkillRegistryPort<LearningSkillView<Run2skillAgent>>;
-  readonly settings: DshSettingsPort;
   readonly agentPresets: Run2skillAgentPresets;
   /** Host-plane DSH filesystem used by the supported web presets. */
   readonly fs: unknown;
@@ -5763,6 +5754,6 @@ declare class Run2skillRuntimeFactory implements RecoveryRuntimeFactory {
   resolvePurgeScope(scope: 'PROJECT' | 'USER', workspaceId?: string): Promise<PurgeScopeBindingV1>;
   open(): Promise<RecoveryRuntime>;
 }
-declare function apply(context: Run2skillHostContext): Promise<() => Promise<void>>;
+declare function apply(context: Run2skillHostContext, config: AutomaticLearningConfig): Promise<() => Promise<void>>;
 //#endregion
-export { ApprovalPublicationSaga, ApprovalPublicationSagaOptions, ApprovedProposalRevalidator, PublicationConflict, PublicationFileSystemPort, PublicationFileSystemResult, PublicationReadbackPort, PublicationReadbackResult, PublicationRevalidationPort, PublicationRevalidationResult, PublicationRootPreparation, PublicationScheduler, PublicationSchedulerOptions, PublicationSingleFlightPort, PublicationTargetSingleFlight, PublicationWorkerPort, Run2skillHostContext, Run2skillRuntimeFactory, V2ProposalPublicationCoordinator, V2ProposalPublicationError, V2ProposalPublicationInput, V2ProposalPublicationOptions, V2ProposalPublicationOutcome, V2ProposalPublicationRecoveryOutcome, V2ProposalPublicationRequest, V2ProposalPublicationResult, apply, createBundle, finalizeTransaction, inject, mergeBundle, name, preparePublicationRoot, recoverTransaction };
+export { ApprovalPublicationSaga, ApprovalPublicationSagaOptions, ApprovedProposalRevalidator, Config, PublicationConflict, PublicationFileSystemPort, PublicationFileSystemResult, PublicationReadbackPort, PublicationReadbackResult, PublicationRevalidationPort, PublicationRevalidationResult, PublicationRootPreparation, PublicationScheduler, PublicationSchedulerOptions, PublicationSingleFlightPort, PublicationTargetSingleFlight, PublicationWorkerPort, Run2skillHostContext, Run2skillRuntimeFactory, V2ProposalPublicationCoordinator, V2ProposalPublicationError, V2ProposalPublicationInput, V2ProposalPublicationOptions, V2ProposalPublicationOutcome, V2ProposalPublicationRecoveryOutcome, V2ProposalPublicationRequest, V2ProposalPublicationResult, apply, createBundle, finalizeTransaction, inject, mergeBundle, name, preparePublicationRoot, recoverTransaction };