@vimhead.dev/norn 0.1.0-tip.35359392805.1 → 0.1.0-tip.35390859630.1

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import type { CreateAgentSessionOptions, EventBus, PromptOptions } from "@earendil-works/pi-coding-agent";
-import { Type, type Static, type StaticDecode, type StaticEncode, type TCodec, type TSchema } from "typebox";
+import { Type, type StaticDecode, type StaticEncode, type TCodec, type TSchema } from "typebox";
 import type { TLocalizedValidationError } from "typebox/error";
 declare const WORKFLOW_DECLARATION_KIND = "norn.workflow";
 export type MaybePromise<T> = T | Promise<T>;
@@ -12,27 +12,32 @@ export type NornWorkflowIsolationMode = "runWorkspace" | "project";
 export type NornWorkflowIsolation<Mode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
     readonly mode: Mode;
 };
-export type NornWorkflowDeclaration<Id extends string = string, ParamsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
-    (params: StaticEncode<ParamsSchema>): NornRunNext;
+export type NornWorkflowDeclaration<Id extends string = string, ArgsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode, ConfigSchema extends TSchema | undefined = TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined> = {
+    (args: StaticEncode<ArgsSchema>): NornRunNext;
     readonly kind: typeof WORKFLOW_DECLARATION_KIND;
     readonly id: Id;
     readonly isEntrypoint: boolean;
     readonly instructions?: string;
-    readonly params: ParamsSchema;
-    readonly gate?: NornWorkflowAnyGate;
+    readonly args: ArgsSchema;
+    readonly gate?: NornWorkflowGate<ArgsSchema> & {
+        describe?(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<string>;
+    };
     readonly isolation: NornWorkflowIsolation<IsolationMode>;
+    readonly config?: ConfigSchema;
+    readonly scope: Scope;
+    execute(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
 };
-export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((params: never) => NornRunNext);
-export type NornWorkflowRefSchemaOptions<ParamsSchema extends TSchema = TSchema> = {
-    readonly params?: ParamsSchema;
+export type NornAnyWorkflowDeclaration = Pick<NornWorkflowDeclaration, keyof NornWorkflowDeclaration> & ((args: never) => NornRunNext);
+export type NornWorkflowRefSchemaOptions<ArgsSchema extends TSchema = TSchema> = {
+    readonly args?: ArgsSchema;
 };
 export type NornWorkflowRefInput = StaticEncode<typeof workflowReferenceInputSchema>;
-export type NornWorkflowRefOutput<ParamsSchema extends TSchema> = (params: StaticEncode<ParamsSchema> & object) => NornRunNext;
-export type NornWorkflowParamsInput<TWorkflow extends NornAnyWorkflowDeclaration> = StaticEncode<TWorkflow["params"]>;
-export type NornWorkflowParams<TWorkflow extends NornAnyWorkflowDeclaration> = StaticDecode<TWorkflow["params"]>;
-export type NornWorkflowGate<ParamsSchema extends TSchema> = unknown extends StaticEncode<ParamsSchema> ? NornWorkflowAnyGate : StaticEncode<ParamsSchema> extends Record<string, unknown> ? {
+export type NornWorkflowRefOutput<ArgsSchema extends TSchema> = (args: StaticEncode<ArgsSchema> & object) => NornRunNext;
+export type NornWorkflowArgsInput<TWorkflow extends NornAnyWorkflowDeclaration> = StaticEncode<TWorkflow["args"]>;
+export type NornWorkflowArgs<TWorkflow extends NornAnyWorkflowDeclaration> = StaticDecode<TWorkflow["args"]>;
+export type NornWorkflowGate<ArgsSchema extends TSchema> = unknown extends StaticEncode<ArgsSchema> ? NornWorkflowAnyGate : StaticEncode<ArgsSchema> extends Record<string, unknown> ? {
     readonly enabled: true;
-    readonly fields?: readonly Extract<keyof StaticEncode<ParamsSchema>, string>[];
+    readonly fields?: readonly Extract<keyof StaticEncode<ArgsSchema>, string>[];
 } : {
     readonly enabled: true;
     readonly fields?: never;
@@ -44,94 +49,52 @@ type NornWorkflowInstructions = {
     readonly isEntrypoint: false;
     readonly instructions?: string;
 };
-export type NornWorkflowDefinition<Id extends string | undefined = string | undefined, ParamsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode> = {
-    readonly id?: Id;
-    readonly params: ParamsSchema;
-    readonly gate?: NornWorkflowGate<ParamsSchema>;
-    readonly isolation?: NornWorkflowIsolation<IsolationMode>;
-} & NornWorkflowInstructions;
-export type NornAnyWorkflowDefinition = {
-    readonly id?: string;
-    readonly params: TSchema;
-    readonly gate?: NornWorkflowAnyGate;
-    readonly isolation?: NornWorkflowIsolation;
-} & NornWorkflowInstructions;
-export type NornWorkflowStateDefinition<Schema extends TSchema = TSchema, Id extends string = string> = {
-    readonly id: Id;
-    readonly description?: string;
-    readonly schema: Schema;
-};
-export type NornWorkflowStateDefinitionInput<Schema extends TSchema = TSchema, Id extends string | undefined = string | undefined> = {
-    readonly id?: Id;
-    readonly description?: string;
-    readonly schema: Schema;
-};
-export type NornWorkflowPluginWorkflows = Record<string, NornAnyWorkflowDefinition>;
-export type NornWorkflowPluginStateTree = {
-    readonly [key: string]: NornWorkflowPluginStateTreeNode;
-};
-type NornStateSchema = TSchema & ({
-    readonly "~kind": string;
-} | {
-    readonly "~unsafe": unknown;
-});
-export type NornWorkflowPluginStateTreeNode = NornStateSchema | NornWorkflowStateDefinitionInput | NornWorkflowPluginStateTree;
-type JoinPath<Head extends string, Parts extends readonly string[]> = Parts extends readonly [] ? Head : Parts extends readonly [infer First extends string, ...infer Rest extends string[]] ? JoinPath<`${Head}.${First}`, Rest> : string;
-type NornInvalidGateFields<TWorkflow> = TWorkflow extends {
-    readonly params: infer ParamsSchema extends TSchema;
-    readonly gate: {
-        readonly fields: infer Fields extends readonly string[];
-    };
-} ? Exclude<Fields[number], Extract<keyof StaticEncode<ParamsSchema>, string>> : never;
-type NornValidatedWorkflowGate<TWorkflow> = [NornInvalidGateFields<TWorkflow>] extends [never] ? unknown : {
-    readonly gate: {
-        readonly fields: readonly Extract<keyof StaticEncode<TWorkflow extends {
-            readonly params: infer ParamsSchema extends TSchema;
-        } ? ParamsSchema : TSchema>, string>[];
+type RunForIsolation<Mode extends NornWorkflowIsolationMode> = Mode extends "project" ? NornProjectRun : NornRun;
+type WorkflowConfig<Schema extends TSchema | undefined> = Schema extends TSchema ? StaticDecode<Schema> : undefined;
+export type NornWorkflowContext<ArgsSchema extends TSchema = TSchema, Mode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode, ConfigSchema extends TSchema | undefined = TSchema | undefined, Scope extends NornWorkflowScopeInfo | undefined = NornWorkflowScopeInfo | undefined> = {
+    readonly args: StaticDecode<ArgsSchema>;
+    readonly config: WorkflowConfig<ConfigSchema>;
+    readonly run: RunForIsolation<Mode>;
+} & (Scope extends NornWorkflowScopeInfo ? {
+    readonly scope: {
+        readonly id: Scope["id"];
+        readonly config: WorkflowConfig<Scope["config"]>;
     };
-};
-export type NornValidatedWorkflowGates<Workflows> = {
-    readonly [Key in keyof Workflows]: NornValidatedWorkflowGate<Workflows[Key]>;
-};
-export type NornQualifiedPluginWorkflow<PluginId extends string, WorkflowKey extends string, TWorkflow extends NornAnyWorkflowDefinition> = TWorkflow extends {
-    readonly params: infer ParamsSchema extends TSchema;
-} ? NornWorkflowDeclaration<TWorkflow extends {
-    readonly id: infer ExplicitId extends string;
-} ? ExplicitId : `${PluginId}.${WorkflowKey}`, ParamsSchema, TWorkflow extends {
-    readonly isolation: {
-        readonly mode: infer IsolationMode extends NornWorkflowIsolationMode;
+} : {});
+export type NornWorkflowDefinition<Id extends string = string, ArgsSchema extends TSchema = TSchema, IsolationMode extends NornWorkflowIsolationMode = NornWorkflowIsolationMode, ConfigSchema extends TSchema | undefined = undefined, Scope extends NornWorkflowScopeInfo | undefined = undefined> = {
+    readonly id: Id;
+    readonly args: ArgsSchema;
+    readonly config?: ConfigSchema;
+    readonly isolation?: NornWorkflowIsolation<IsolationMode>;
+    readonly gate?: NornWorkflowGate<ArgsSchema> & {
+        describe?(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<string>;
     };
-} ? IsolationMode : "runWorkspace"> : never;
-export type NornQualifiedPluginWorkflows<PluginId extends string, Workflows extends NornWorkflowPluginWorkflows> = {
-    readonly [Key in keyof Workflows]: NornQualifiedPluginWorkflow<PluginId, Key & string, Workflows[Key]>;
-};
-export type NornQualifiedPluginStates<PluginId extends string, States, Path extends readonly string[] = []> = {
-    readonly [Key in keyof States]: States[Key] extends NornStateSchema ? NornWorkflowStateDefinition<States[Key], JoinPath<PluginId, [...Path, Key & string]>> : States[Key] extends NornWorkflowStateDefinitionInput<infer Schema extends NornStateSchema> ? NornWorkflowStateDefinition<Schema, States[Key] extends {
-        readonly id: infer Id extends string;
-    } ? Id : JoinPath<PluginId, [...Path, Key & string]>> : States[Key] extends NornWorkflowPluginStateTree ? NornQualifiedPluginStates<PluginId, States[Key], [...Path, Key & string]> : never;
+    execute(context: NornWorkflowContext<ArgsSchema, IsolationMode, ConfigSchema, Scope>): MaybePromise<WorkflowResult>;
+} & NornWorkflowInstructions;
+export type NornWorkflowScopeInfo = {
+    readonly id: string;
+    readonly config?: TSchema;
 };
-export type NornWorkflowPluginManifest<PluginId extends string = string, ConfigSchema extends TSchema | undefined = TSchema | undefined, Workflows extends Record<string, NornAnyWorkflowDeclaration> = Record<string, NornAnyWorkflowDeclaration>, States = undefined> = {
-    readonly id: PluginId;
-    readonly config?: ConfigSchema;
-    readonly workflows: Workflows;
-    readonly states: States;
-};
-export type NornAnyWorkflowPluginManifest = NornWorkflowPluginManifest<string, TSchema | undefined, Record<string, NornAnyWorkflowDeclaration>, unknown>;
-export type NornWorkflowPluginConfigSchema<TManifest extends NornAnyWorkflowPluginManifest> = TManifest extends {
-    readonly config?: infer ConfigSchema extends TSchema | undefined;
-} ? ConfigSchema : undefined;
-export type NornWorkflowPluginConfig<TManifest extends NornAnyWorkflowPluginManifest> = NornWorkflowPluginConfigSchema<TManifest> extends undefined ? undefined : StaticDecode<NonNullable<NornWorkflowPluginConfigSchema<TManifest>>>;
-export type NornDefinePluginManifestInput<PluginId extends string, ConfigSchema extends TSchema | undefined, Workflows extends NornWorkflowPluginWorkflows, States extends NornWorkflowPluginStateTree | undefined> = {
-    readonly id: PluginId;
+export type NornWorkflowScope<Id extends string, ConfigSchema extends TSchema | undefined> = {
+    readonly id: Id;
+    readonly config: ConfigSchema;
+    workflow<const LocalId extends string, ArgsSchema extends TSchema, const Mode extends NornWorkflowIsolationMode = "runWorkspace", LocalConfig extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<LocalId, ArgsSchema, Mode, LocalConfig, {
+        readonly id: Id;
+        readonly config: ConfigSchema;
+    }>): NornWorkflowDeclaration<`${Id}.${LocalId}`, ArgsSchema, Mode, LocalConfig, {
+        readonly id: Id;
+        readonly config: ConfigSchema;
+    }>;
+};
+export declare function workflow<const Id extends string, ArgsSchema extends TSchema, const Mode extends NornWorkflowIsolationMode = "runWorkspace", ConfigSchema extends TSchema | undefined = undefined>(definition: NornWorkflowDefinition<Id, ArgsSchema, Mode, ConfigSchema>): NornWorkflowDeclaration<Id, ArgsSchema, Mode, ConfigSchema, undefined>;
+export declare function workflowScope<const Id extends string, ConfigSchema extends TSchema | undefined = undefined>(input: {
+    readonly id: Id;
     readonly config?: ConfigSchema;
-    readonly workflows: Workflows & NornValidatedWorkflowGates<Workflows>;
-    readonly states?: States;
-};
-export declare function definePluginManifest<const PluginId extends string, const ConfigSchema extends TSchema | undefined = undefined, const Workflows extends NornWorkflowPluginWorkflows = NornWorkflowPluginWorkflows, const States extends NornWorkflowPluginStateTree | undefined = undefined>(input: NornDefinePluginManifestInput<PluginId, ConfigSchema, Workflows, States>): NornWorkflowPluginManifest<PluginId, ConfigSchema, NornQualifiedPluginWorkflows<PluginId, Workflows>, States extends NornWorkflowPluginStateTree ? NornQualifiedPluginStates<PluginId, States> : undefined>;
+}): NornWorkflowScope<Id, ConfigSchema>;
 export type NornRunNext = {
     readonly type: "next";
     readonly workflowId: string;
-    readonly params: unknown;
+    readonly args: unknown;
 };
 export type NornRunOutcomeMetadata = {
     readonly summary?: string;
@@ -149,19 +112,12 @@ export type NornRunFail = {
         readonly summary: string;
     };
 };
-export type NornWorkflowExecutionResult = NornRunNext | NornRunComplete | NornRunFail;
+export type WorkflowResult = NornRunNext | NornRunComplete | NornRunFail;
 export type NornRunFor<TWorkflow extends NornAnyWorkflowDeclaration> = TWorkflow extends {
     readonly isolation: {
         readonly mode: "project";
     };
 } ? NornProjectRun : NornRun;
-export type NornWorkflowGateImplementation<TWorkflow extends NornAnyWorkflowDeclaration, TConfig> = {
-    describe(run: NornRunFor<TWorkflow>, params: NornWorkflowParams<TWorkflow>, config: TConfig): MaybePromise<string>;
-};
-export type NornWorkflowImplementation<TWorkflow extends NornAnyWorkflowDeclaration, TConfig = unknown> = {
-    readonly gate?: NornWorkflowGateImplementation<TWorkflow, TConfig>;
-    execute(run: NornRunFor<TWorkflow>, params: NornWorkflowParams<TWorkflow>, config: TConfig): MaybePromise<NornWorkflowExecutionResult>;
-};
 export type NornRunStartOptions = {
     readonly id?: string;
     readonly name?: string;
@@ -206,7 +162,7 @@ export type NornStoppedRunResult = {
 };
 export type NornRunInterruption = {
     readonly workflowId: string;
-    readonly params: unknown;
+    readonly args: unknown;
     readonly description: string;
     readonly fields?: readonly string[];
 };
@@ -261,29 +217,6 @@ export type NornRunCheckpoint = {
     readonly message: string;
     readonly createdAt: string;
 };
-export type NornWorkflowStateReader = {
-    get<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema>>;
-    getOptional<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>): Promise<Static<Schema> | undefined>;
-};
-export type NornWorkflowState = NornWorkflowStateReader & {
-    set<Schema extends TSchema>(state: NornWorkflowStateDefinition<Schema>, value: NoInfer<Static<Schema>>): Promise<void>;
-};
-export type NornWorkflowPluginContext = {
-    readonly cwd: string;
-    readonly state: NornWorkflowState;
-};
-export type NornWorkflowPluginImplementation<TManifest extends NornAnyWorkflowPluginManifest> = {
-    readonly workflows: {
-        readonly [Key in keyof TManifest["workflows"]]: NornWorkflowImplementation<TManifest["workflows"][Key], NornWorkflowPluginConfig<TManifest>>;
-    };
-};
-export type NornWorkflowPluginImplementationFactory<TManifest extends NornAnyWorkflowPluginManifest> = (context: NornWorkflowPluginContext) => NornWorkflowPluginImplementation<TManifest>;
-export type NornWorkflowPluginImplementationInput<TManifest extends NornAnyWorkflowPluginManifest> = NornWorkflowPluginImplementation<TManifest> | NornWorkflowPluginImplementationFactory<TManifest>;
-export type NornWorkflowPlugin<TManifest extends NornAnyWorkflowPluginManifest = NornAnyWorkflowPluginManifest> = {
-    readonly manifest: TManifest;
-    readonly implementation: NornWorkflowPluginImplementationInput<TManifest>;
-};
-export declare function definePlugin<TManifest extends NornAnyWorkflowPluginManifest>(manifest: TManifest, implementation: NornWorkflowPluginImplementationInput<TManifest>): NornWorkflowPlugin<TManifest>;
 export type NornCommandRunInput = {
     readonly label: string;
     readonly command: string | readonly [string, ...string[]];
@@ -295,12 +228,12 @@ export declare const artifactRefSchema: Type.TObject<{
     path: Type.TString;
 }>;
 export type NornArtifactRef = StaticDecode<typeof artifactRefSchema>;
-declare const emptyWorkflowRefParamsSchema: Type.TObject<{}>;
+declare const emptyWorkflowRefArgsSchema: Type.TObject<{}>;
 declare const workflowReferenceInputSchema: Type.TUnion<[Type.TString, Type.TObject<{
     workflow: Type.TString;
-    forwardParams: Type.TRecord<"^.*$", Type.TUnknown>;
+    forwardArgs: Type.TRecord<"^.*$", Type.TUnknown>;
 }>]>;
-export declare function workflowRefSchema<ParamsSchema extends TSchema = typeof emptyWorkflowRefParamsSchema>(options?: NornWorkflowRefSchemaOptions<ParamsSchema>): TCodec<typeof workflowReferenceInputSchema, NornWorkflowRefOutput<ParamsSchema>>;
+export declare function workflowRefSchema<ArgsSchema extends TSchema = typeof emptyWorkflowRefArgsSchema>(options?: NornWorkflowRefSchemaOptions<ArgsSchema>): TCodec<typeof workflowReferenceInputSchema, NornWorkflowRefOutput<ArgsSchema>>;
 export type NornLogRef = {
     readonly id: string;
 };
@@ -443,13 +376,12 @@ type NornRunBase = {
     workspace: string;
     cwd: string;
     path(relativePath: string): string;
-    next(workflowId: string, params: unknown): NornRunNext;
+    next(workflowId: string, args: unknown): NornRunNext;
     complete(metadata?: NornRunOutcomeMetadata): NornRunComplete;
     fail(metadata: NornRunOutcomeMetadata & {
         readonly summary: string;
     }): NornRunFail;
     resources: import("./resources.ts").NornResources;
-    state: NornWorkflowState;
     artifacts: {
         write(path: string, content: string): Promise<NornArtifactRef>;
         read(ref: NornArtifactRef): Promise<string>;
@@ -465,10 +397,9 @@ type NornRunBase = {
         prompt<ResponseSchema extends TSchema>(input: NornAgentSinglePromptInput<ResponseSchema>): Promise<StaticDecode<ResponseSchema>>;
     };
 };
-export type NornWorkflowPluginInfo = {
-    readonly id: string;
-    readonly path?: string;
-    readonly configPath?: string;
+export type NornWorkflowSource = {
+    readonly path: string;
+    readonly configPath: string;
 };
 export type NornJsonSchema = Record<string, unknown>;
 export type NornWorkflowGateInfo = {
@@ -480,24 +411,34 @@ export type NornRegisteredWorkflowInfo = {
     readonly instructions?: string;
     readonly isEntrypoint: boolean;
     readonly isolation: NornWorkflowIsolation;
-    readonly plugin?: NornWorkflowPluginInfo;
+    readonly scope?: {
+        readonly id: string;
+    };
+    readonly source?: NornWorkflowSource;
+    readonly configKey: string;
 };
 export type NornInspectedWorkflowInfo = NornRegisteredWorkflowInfo & {
-    readonly paramsSchema: NornJsonSchema;
+    readonly scope?: {
+        readonly id: string;
+        readonly configKey: string;
+        readonly configSchema: NornJsonSchema | null;
+    };
+    readonly argsSchema: NornJsonSchema;
+    readonly configSchema: NornJsonSchema | null;
     readonly gate: NornWorkflowGateInfo | null;
 };
-export type NornPluginDiagnostic = {
+export type NornWorkflowDiagnostic = {
     readonly configPath: string;
-    readonly pluginPath: string;
-    readonly pluginId: string | null;
+    readonly modulePath: string;
+    readonly scopeId: string | null;
     readonly workflowId: string | null;
-    readonly stage: "import" | "declaration" | "config" | "implementation" | "duplicate" | "schema";
+    readonly stage: "import" | "declaration" | "config" | "duplicate" | "schema";
     readonly message: string;
     readonly issues: readonly TLocalizedValidationError[];
 };
 export type NornProjectLoadStatus = {
     readonly isComplete: boolean;
-    readonly diagnostics: readonly NornPluginDiagnostic[];
+    readonly diagnostics: readonly NornWorkflowDiagnostic[];
 };
 export type NornWorkflowCatalogInfo = NornProjectLoadStatus & {
     readonly workflows: readonly NornRegisteredWorkflowInfo[];
@@ -508,7 +449,9 @@ export type NornWorkflowInspection = NornProjectLoadStatus & {
 export type NornProjectInspection = NornProjectLoadStatus & {
     readonly project: NornProjectInfo;
 };
-export type NornProjectPluginInfo = NornWorkflowPluginInfo & {
+export type NornProjectConfigurationInfo = {
+    readonly key: string;
+    readonly scopeId: string | null;
     readonly configSchema: NornJsonSchema | null;
     readonly config: unknown;
 };
@@ -519,11 +462,10 @@ export type NornProjectInfo = {
     readonly configPath: string;
     readonly configRoot: string;
     readonly configFiles: readonly string[];
-    readonly plugins: readonly NornProjectPluginInfo[];
+    readonly configurations: readonly NornProjectConfigurationInfo[];
+    readonly modules: readonly NornWorkflowSource[];
 };
 export declare function isWorkflowDeclaration(value: unknown): value is NornAnyWorkflowDeclaration;
-export declare function isWorkflowPlugin(value: unknown): value is NornWorkflowPlugin;
-export declare function isWorkflowPluginManifest(value: unknown): value is NornAnyWorkflowPluginManifest;
 export declare function isWorkflowNext(value: unknown): value is NornRunNext;
 export declare function isWorkflowComplete(value: unknown): value is NornRunComplete;
 export declare function isWorkflowFail(value: unknown): value is NornRunFail;

package/dist/api.js

@@ -4,103 +4,69 @@ import { Type } from "typebox";
 // ../core/src/workflow-transition.ts
 function createWorkflowTransition(input) {
   if (typeof input.workflowId !== "string" || input.workflowId.trim().length === 0) throw new Error("Workflow transition requires a nonempty workflow ID");
-  return { type: "next", workflowId: input.workflowId, params: input.params };
+  return { type: "next", workflowId: input.workflowId, args: input.args };
 }
 
 // src/api.ts
 import { Value } from "typebox/value";
-import { isPlainObject, jsonValueSchema } from "./schema.js";
+import { assertWorkflowMetadata, isPlainObject, jsonValueSchema } from "./schema.js";
 var WORKFLOW_DECLARATION_KIND = "norn.workflow";
-function definePluginManifest(input) {
-  assertLocalDeclarationId(input.id, "plugin");
-  const declaredIds = /* @__PURE__ */ new Set();
-  const workflows = Object.fromEntries(
-    Object.entries(input.workflows).map(([key, workflow]) => [key, qualifyWorkflow(input.id, key, workflow, declaredIds)])
-  );
+function workflow(definition) {
+  return createWorkflow({ definition, scope: void 0 });
+}
+function createWorkflow(input) {
+  const { definition, scope } = input;
+  assertDeclarationId(definition.id);
+  const callable = (args) => createWorkflowTransition({ workflowId: definition.id, args });
+  const result = Object.assign(callable, definition, {
+    kind: WORKFLOW_DECLARATION_KIND,
+    scope,
+    isolation: definition.isolation ?? { mode: "runWorkspace" }
+  });
+  if (!isWorkflowDeclaration(result)) throw new Error(`Invalid workflow definition: ${definition.id}`);
+  assertWorkflowMetadata(result);
+  return result;
+}
+function workflowScope(input) {
+  assertDeclarationId(input.id);
+  const scope = { id: input.id, config: input.config };
   return {
     id: input.id,
     config: input.config,
-    workflows,
-    states: qualifyStateTree(input.id, input.states, [], declaredIds)
+    workflow(definition) {
+      assertDeclarationId(definition.id);
+      return createWorkflow({ definition: { ...definition, id: `${input.id}.${definition.id}` }, scope });
+    }
   };
 }
-function definePlugin(manifest, implementation) {
-  return { manifest, implementation };
-}
 var artifactRefSchema = Type.Object({
   path: Type.String()
 });
-var emptyWorkflowRefParamsSchema = Type.Object({});
+var emptyWorkflowRefArgsSchema = Type.Object({});
 var workflowReferenceInputSchema = Type.Union([
   Type.String({ minLength: 1 }),
-  Type.Object({ workflow: Type.String({ minLength: 1 }), forwardParams: Type.Record(Type.String(), Type.Unknown()) })
+  Type.Object({ workflow: Type.String({ minLength: 1 }), forwardArgs: Type.Record(Type.String(), Type.Unknown()) })
 ]);
 function workflowRefSchema(options) {
-  const contributionSchema = options?.params ?? emptyWorkflowRefParamsSchema;
+  const contributionSchema = options?.args ?? emptyWorkflowRefArgsSchema;
   return Type.With(Type.Decode(workflowReferenceInputSchema, (reference) => {
     const workflowId = typeof reference === "string" ? reference : reference.workflow;
-    const forwardParams = typeof reference === "string" ? {} : reference.forwardParams;
-    return (params) => {
-      Value.Assert(contributionSchema, params);
-      if (!isPlainObject(params)) throw new Error("Workflow reference contributions must be objects");
-      Value.Assert(jsonValueSchema, params);
-      return createWorkflowTransition({ workflowId, params: { ...forwardParams, ...params } });
+    const forwardArgs = typeof reference === "string" ? {} : reference.forwardArgs;
+    return (args) => {
+      Value.Assert(contributionSchema, args);
+      if (!isPlainObject(args)) throw new Error("Workflow reference contributions must be objects");
+      Value.Assert(jsonValueSchema, args);
+      return createWorkflowTransition({ workflowId, args: { ...forwardArgs, ...args } });
     };
-  }), { "x-norn-workflow-ref": { contributedParamsSchema: contributionSchema } });
-}
-function assertLocalDeclarationId(id, kind) {
-  if (id.length === 0) throw new Error(`Workflow ${kind} id must not be empty`);
-  if (id.includes(".")) throw new Error(`Workflow ${kind} id must not contain dots: ${id}`);
-}
-function resolveDeclarationId(pluginId, path, explicitId, kind, declaredIds) {
-  for (const segment of path) assertLocalDeclarationId(segment, kind);
-  const id = explicitId ?? [pluginId, ...path].join(".");
-  if (explicitId !== void 0) assertPluginQualifiedId(pluginId, explicitId, kind);
-  if (declaredIds.has(id)) throw new Error(`Duplicate Norn ${kind} id: ${id}`);
-  declaredIds.add(id);
-  return id;
-}
-function assertPluginQualifiedId(pluginId, id, kind) {
-  if (!id.startsWith(`${pluginId}.`)) throw new Error(`Explicit Norn ${kind} id must start with ${pluginId}.: ${id}`);
-  if (id.length === pluginId.length + 1) throw new Error(`Explicit Norn ${kind} id must not be empty after ${pluginId}.`);
+  }), { "x-norn-workflow-ref": { contributedArgsSchema: contributionSchema } });
 }
-function qualifyWorkflow(pluginId, key, workflow, declaredIds) {
-  const id = resolveDeclarationId(pluginId, [key], workflow.id, "workflow", declaredIds);
-  const declaration = (params) => createWorkflowTransition({ workflowId: id, params });
-  return Object.assign(declaration, { ...workflow, kind: WORKFLOW_DECLARATION_KIND, id, isolation: workflow.isolation ?? { mode: "runWorkspace" } });
-}
-function qualifyStateTree(pluginId, node, path, declaredIds) {
-  if (node === void 0) return void 0;
-  if (isTypeboxSchema(node)) return { id: resolveDeclarationId(pluginId, path, void 0, "state", declaredIds), schema: node };
-  if (path.length > 0 && isWorkflowStateDefinitionInput(node)) {
-    return { ...node, id: resolveDeclarationId(pluginId, path, node.id, "state", declaredIds) };
-  }
-  if (!isPlainObject(node)) throw new Error(`Invalid state declaration: ${[pluginId, ...path].join(".")}`);
-  return Object.fromEntries(Object.entries(node).map(([key, child]) => [key, qualifyStateTree(pluginId, child, [...path, key], declaredIds)]));
+function assertDeclarationId(id) {
+  if (typeof id !== "string" || id.trim().length === 0 || id.split(".").some((segment) => segment.length === 0)) throw new Error(`Invalid workflow or scope id: ${id}`);
 }
 function isWorkflowDeclaration(value) {
   if (typeof value !== "function") return false;
   const candidate = value;
-  return candidate.kind === WORKFLOW_DECLARATION_KIND && typeof candidate.id === "string" && candidate.id.length > 0 && (candidate.instructions === void 0 || typeof candidate.instructions === "string") && typeof candidate.isEntrypoint === "boolean" && Boolean(candidate.params) && (candidate.isolation?.mode === "runWorkspace" || candidate.isolation?.mode === "project");
-}
-function isTypeboxSchema(value) {
-  return Type.IsUnsafe(value) || Boolean(value && typeof value === "object" && "~kind" in value && typeof value["~kind"] === "string");
-}
-function isWorkflowStateDefinitionInput(value) {
-  if (!isPlainObject(value)) return false;
-  return (value.id === void 0 || typeof value.id === "string") && isTypeboxSchema(value.schema);
-}
-function isWorkflowPlugin(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return isWorkflowPluginManifest(candidate.manifest) && Boolean(candidate.implementation);
-}
-function isWorkflowPluginManifest(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  if (typeof candidate.id !== "string" || candidate.id.length === 0) return false;
-  if (!candidate.workflows || typeof candidate.workflows !== "object") return false;
-  return Object.values(candidate.workflows).every(isWorkflowDeclaration);
+  return candidate.kind === WORKFLOW_DECLARATION_KIND && typeof candidate.id === "string" && candidate.id.length > 0 && (candidate.instructions === void 0 || typeof candidate.instructions === "string") && typeof candidate.isEntrypoint === "boolean" && Boolean(candidate.args) && typeof candidate.execute === "function" && (candidate.isolation?.mode === "runWorkspace" || candidate.isolation?.mode === "project");
 }
 function isWorkflowNext(value) {
   if (!value || typeof value !== "object") return false;
@@ -119,13 +85,11 @@ function isWorkflowFail(value) {
 }
 export {
   artifactRefSchema,
-  definePlugin,
-  definePluginManifest,
   isWorkflowComplete,
   isWorkflowDeclaration,
   isWorkflowFail,
   isWorkflowNext,
-  isWorkflowPlugin,
-  isWorkflowPluginManifest,
-  workflowRefSchema
+  workflow,
+  workflowRefSchema,
+  workflowScope
 };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
+export type { CreateAgentSessionOptions, EventBus, PromptOptions, ToolDefinition } from "@earendil-works/pi-coding-agent";
 export * from "./api.ts";
 export { NornFileCoordinator } from "./files.ts";
 export * from "./resources.ts";
 export * from "./agent-resource-adapter.ts";
-export * from "./state-adapter.ts";

package/dist/index.js

@@ -3,7 +3,6 @@ export * from "./api.js";
 import { NornFileCoordinator } from "./files.js";
 export * from "./resources.js";
 export * from "./agent-resource-adapter.js";
-export * from "./state-adapter.js";
 export {
   NornFileCoordinator
 };

package/dist/schema.js

@@ -23,9 +23,9 @@ function assertWorkflowReferenceAnnotations(schema) {
   if (!isPlainObject(schema)) return;
   if (Object.hasOwn(schema, "x-norn-workflow-ref")) {
     const annotation = schema["x-norn-workflow-ref"];
-    if (!isPlainObject(annotation) || !Object.hasOwn(annotation, "contributedParamsSchema")) throw new Error("Invalid workflow reference annotation");
-    Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedParamsSchema);
-    assertWorkflowReferenceAnnotations(annotation.contributedParamsSchema);
+    if (!isPlainObject(annotation) || !Object.hasOwn(annotation, "contributedArgsSchema")) throw new Error("Invalid workflow reference annotation");
+    Value.Assert(Meta["https://json-schema.org/draft/2020-12/schema"], annotation.contributedArgsSchema);
+    assertWorkflowReferenceAnnotations(annotation.contributedArgsSchema);
   }
   for (const keyword of ["properties", "patternProperties", "$defs", "definitions", "dependentSchemas"]) {
     const schemas = schema[keyword];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vimhead.dev/norn",
-  "version": "0.1.0-tip.35359392805.1",
+  "version": "0.1.0-tip.35390859630.1",
   "description": "TypeScript SDK for building agent-driven and code-driven Norn workflows.",
   "type": "module",
   "license": "MIT",

package/dist/state-adapter.d.ts

@@ -1,10 +0,0 @@
-import type { NornAgentResourceAdapter } from "./agent-resource-adapter.ts";
-import type { NornWorkflowState, NornWorkflowStateDefinition } from "./api.ts";
-export type NornStateFieldAccess = {
-    readonly field: NornWorkflowStateDefinition;
-    readonly access: "read" | "write" | "read-write";
-};
-export declare function StateAdapter(input: {
-    readonly state: NornWorkflowState;
-    readonly fields: readonly NornStateFieldAccess[];
-}): NornAgentResourceAdapter;

package/dist/state-adapter.js

@@ -1,70 +0,0 @@
-// src/state-adapter.ts
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { createHash } from "node:crypto";
-import { Type } from "typebox";
-import { inspectSchema } from "./schema.js";
-var pageParameters = {
-  offset: Type.Integer({ minimum: 0, description: "Zero-based UTF-16 offset into the serialized JSON. Start at 0." }),
-  limit: Type.Integer({ minimum: 1, maximum: 1e4 })
-};
-function StateAdapter(input) {
-  const fields = new Map(input.fields.map((grant) => [grant.field.id, grant]));
-  if (fields.size !== input.fields.length || fields.size === 0) throw new Error("State attachment requires unique, explicitly selected fields");
-  const selectField = (key, access) => {
-    const grant = fields.get(key);
-    if (!grant || grant.access !== access && grant.access !== "read-write") throw new Error(`State ${access} is not attached: ${key}`);
-    return grant.field;
-  };
-  return {
-    name: "norn.state",
-    async bind() {
-      return {
-        tools: [
-          defineTool({
-            name: "norn_state_list",
-            label: "Attached workflow state",
-            description: "List only attached workflow-state field IDs, permissions and value schemas. JSON is paginated; use nextOffset until null.",
-            parameters: Type.Object(pageParameters),
-            async execute(_id, params) {
-              return serializePage({ value: [...fields.values()].map(({ field, access }) => ({ id: field.id, access, schema: inspectSchema(field.schema) })), ...params });
-            }
-          }),
-          defineTool({
-            name: "norn_state_get",
-            label: "Read workflow state",
-            description: "Read a selected workflow-state field. Unset fields return isSet:false. JSON is paginated; concurrent writes can change later pages, so compare revision before combining pages.",
-            parameters: Type.Object({ key: Type.String(), ...pageParameters }),
-            async execute(_id, params) {
-              const value = await input.state.getOptional(selectField(params.key, "read"));
-              return serializePage({ value: value === void 0 ? { isSet: false } : { isSet: true, value }, ...params });
-            }
-          }),
-          defineTool({
-            name: "norn_state_set",
-            label: "Write workflow state",
-            description: "Set an explicitly writable workflow-state field. Validate the value against its schema from norn_state_list. A get followed by set is not a transaction.",
-            parameters: Type.Object({ key: Type.String(), value: Type.Unknown() }),
-            async execute(_id, params, signal) {
-              signal?.throwIfAborted();
-              const field = selectField(params.key, "write");
-              await input.state.set(field, params.value);
-              return { content: [{ type: "text", text: "Workflow state saved." }], details: {} };
-            }
-          })
-        ],
-        async dispose() {
-        }
-      };
-    }
-  };
-}
-function serializePage(input) {
-  const serialized = JSON.stringify(input.value);
-  if (!Number.isInteger(input.offset) || input.offset < 0 || !Number.isInteger(input.limit) || input.limit < 1 || input.limit > 1e4) throw new Error("Invalid state output page");
-  const end = Math.min(serialized.length, input.offset + input.limit);
-  const details = { text: serialized.slice(input.offset, end), nextOffset: end < serialized.length ? end : null, revision: createHash("sha256").update(serialized).digest("hex") };
-  return { content: [{ type: "text", text: JSON.stringify(details) }], details };
-}
-export {
-  StateAdapter
-};