@sigrun/sigrun 0.4.2 → 0.6.0

package/dist/server/conversation-ops.js

@@ -20,6 +20,7 @@ import { AgentDoc, configure } from "@earendil-works/pi-durable";
 import { accessOf, isSharing, } from "@sigrun/shared/access";
 import { extname } from "node:path";
 import { touchActivity } from "../harness/activity.js";
+import { ensureRequestId, recordAuthor, } from "../curation/attribution.js";
 import { resolveServedModelRefreshing } from "../harness/providers/refresh.js";
 import { isSuperuser } from "./auth/principal.js";
 import { isConfinedPath, parseSubmissionInput } from "./content-parts.js";
@@ -145,6 +146,17 @@ export async function createConversationOp(ctx, input = {}) {
     if (input.name !== undefined && typeof input.name !== "string") {
         throw new ConversationOpError({ error: "invalid_field", field: "name" });
     }
+    if (input.job !== undefined) {
+        // Resolve the live job (and therefore its EFFECTIVE owner) before the
+        // createConversation table write or the session-meta commit. An absent
+        // requested owner and an absent effective owner are an exact match.
+        const job = typeof input.job === "string"
+            ? await opened.jobs.get(input.job)
+            : undefined;
+        if (job === undefined || input.owner !== job.owner) {
+            throw new ConversationOpError({ error: "invalid_field", field: "job" });
+        }
+    }
     if (input.source !== undefined && typeof input.source !== "string") {
         throw new ConversationOpError({ error: "invalid_field", field: "source" });
     }
@@ -226,6 +238,8 @@ export async function createConversationOp(ctx, input = {}) {
         }
         if (input.name !== undefined)
             draft.name = input.name;
+        if (input.job !== undefined)
+            draft.jobId = input.job;
         if (input.source !== undefined)
             draft.source = input.source;
         await opened.rewriteUserSelection(tx, conversation.id, undefined, input.owner);
@@ -247,6 +261,9 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
     if (!parsed.ok) {
         throw new ConversationOpError({ error: "invalid_input" });
     }
+    // Every input carries a requestId (curator P1): the caller's own id, or
+    // a generated `sigrun:` UUID — the pre-admission attribution key.
+    const requestId = ensureRequestId(opts.requestId);
     // Spec §2/§3 binding contract: a conversation pinned to an unserved
     // model fails explicitly AT SUBMIT — 4xx with the available ids —
     // never a silent fallback, and never a settled no_model run surfaced
@@ -316,7 +333,11 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
     else {
         try {
             const env = await envThunk();
-            expansion = await expandInput(parsed.parts, opened.commandExpansion, env, BACKGROUND_CONTEXT);
+            // Curator A3: the learned root resolves through the conversation
+            // OWNER (SessionMetaDoc), not the submitting user — a shared-write
+            // submitter expands against the owner's learned skills.
+            const meta = await opened.harness.snapshot(SessionMetaDoc, conversation.id, BACKGROUND_CONTEXT);
+            expansion = await expandInput(parsed.parts, opened.commandExpansion, env, BACKGROUND_CONTEXT, meta?.owner);
         }
         catch (error) {
             if (error instanceof CommandUsageError) {
@@ -356,13 +377,20 @@ export async function submitOp(ctx, conversation, input, opts = {}) {
     const draft = {
         type: "input",
         content,
-        ...(opts.requestId === undefined ? {} : { requestId: opts.requestId }),
+        requestId,
         ...(whenBusy === undefined ? {} : { whenBusy: whenBusy }),
         ...(entry === undefined ? {} : { entry }),
     };
+    // Attribution (curator P1), two writes per input: `byRequest` BEFORE the
+    // admission (the requestId exists pre-admission, so this never races; an
+    // orphan record from a failed submit is harmless) and `bySubmission`
+    // right after it returns — the key the live run's input ids resolve
+    // against. An `undefined` user records nothing (unattributed).
+    await recordAuthor(conversation, { requestId }, opts.user, BACKGROUND_CONTEXT);
     // The submit pass-through is retired (§6.7): the memory seam's
     // runSettled owns capture, so submissions admit directly.
     const submission = await conversation.submit(draft, BACKGROUND_CONTEXT);
+    await recordAuthor(conversation, { submissionId: submission.id }, opts.user, BACKGROUND_CONTEXT);
     // Admission stamps activity: the sidebar's activity sort must move the
     // moment a prompt lands — before the run settles.
     await touchActivity(opened.harness, conversation.id, opened.now, BACKGROUND_CONTEXT);
@@ -394,7 +422,10 @@ export async function listConversationsOp(ctx, caller, filters = {}) {
             // flags, and the create source (spec §9.5).
             const meta = await opened.harness.snapshot(SessionMetaDoc, record.id, BACKGROUND_CONTEXT);
             const access = accessOf(caller, meta ?? {});
-            // Hidden is absent from the list (spec §5.9).
+            // Hidden is absent from the list (spec §5.9) — and internal means
+            // hidden for EVERY caller (curator P5, accessOf rule 0): the
+            // superuser and the bridge's trusted read are covered by the same
+            // line, so no caller-specific skip can drift.
             if (access === "none")
                 continue;
             // The archived filter (absent = all).

package/dist/server/helpers.js

@@ -86,7 +86,7 @@ function autoEnableRemovals(settings, env) {
         const server = entry;
         if (server.enabled === false || server.disabled === true)
             continue;
-        // @sigrun/ext-mcp's server default is "codemode"; its pi-compat
+        // @sigrun/ext-mcp's server default is "codemode"; its deprecated
         // alias `codemode-deferred` normalizes to "codemode".
         const exposure = server.exposure === "codemode-deferred"
             ? "codemode"

package/dist/server/host-bridge.js

@@ -22,6 +22,7 @@ import { userWire } from "./routes/users.js";
 import { accessPrincipalOf } from "./auth/access-principal.js";
 import { abortOp, compactOp, configureOp, ConversationOpError, createConversationOp, forkOp, listConversationsOp, patchMetaOp, readFileOp, readMetaOp, submitOp, uploadOp, } from "./conversation-ops.js";
 import { listModels } from "./helpers.js";
+import { notifyExtension } from "./notifications.js";
 import { SessionMetaDoc } from "./session-meta.js";
 import { accountLinkWire, serializeConversationView } from "./views.js";
 /**
@@ -59,11 +60,13 @@ export function createHostBridge(ctx) {
                 const conversation = await conversationOf(id);
                 // `user` is accepted and NOT verified: extensions own their
                 // user mapping (spec §9.5) — a channel's unmapped user submits
-                // fine, and owner attribution happened at create.
+                // fine, and owner attribution happened at create. P1 records
+                // it verbatim as the input's author.
                 return await submitOp(ctx, conversation, input, {
                     ...(opts?.requestId === undefined
                         ? {}
                         : { requestId: opts.requestId }),
+                    ...(opts?.user === undefined ? {} : { user: opts.user }),
                     ...(opts?.whenBusy === undefined
                         ? {}
                         : { whenBusy: opts.whenBusy }),
@@ -106,6 +109,15 @@ export function createHostBridge(ctx) {
                 await conversationOf(id);
                 return await readMetaOp(opened, id);
             },
+            async entries(id, query, limit, cursor) {
+                const conversation = await conversationOf(id);
+                return await conversation.entries(query, limit, cursor, BACKGROUND_CONTEXT);
+            },
+            async entry(id, entryId) {
+                const conversation = await conversationOf(id);
+                const page = await conversation.entries({ minEntryId: entryId, maxEntryId: entryId }, 1, undefined, BACKGROUND_CONTEXT);
+                return page.items[0];
+            },
             // Gateway C4a: the remaining conversation ops, each the SAME op
             // its HTTP route runs — resolved through conversationOf (unknown id
             // → the bridge's loud `conversation <id> not found`).
@@ -168,6 +180,20 @@ export function createHostBridge(ctx) {
                 return await readFileOp(ctx, conversation, path);
             },
         },
+        jobs: {
+            async get(id) {
+                const job = await opened.jobs.get(id);
+                if (job === undefined)
+                    return undefined;
+                return {
+                    id: job.id,
+                    name: job.name,
+                    ...(job.owner === undefined ? {} : { owner: job.owner }),
+                    enabled: job.enabled,
+                    state: job.state,
+                };
+            },
+        },
         users: {
             // The directory in wire form (emails are admin material; the
             // bridge is in-process server code, the same trust as the
@@ -277,6 +303,7 @@ export function createHostBridge(ctx) {
                     : { notice: result.notice };
             },
         },
+        notify: (slug, input) => notifyExtension(ctx, slug, input),
         surfaces: {
             // UI-blocks U3 Task 4 (spec §7.3): the same bumpRev the actions
             // route takes — the rev advance and the hub event are one step.
@@ -284,5 +311,8 @@ export function createHostBridge(ctx) {
                 ctx.surfaces.bumpRev(slug, id, key, update);
             },
         },
+        // Curator P6 (A9): the boot-built curation host, verbatim — the
+        // ONE instance every seam host reaches through this bridge.
+        curation: ctx.opened.curationHost,
     };
 }

package/dist/server/notifications.js

@@ -40,6 +40,29 @@ import { SessionMetaDoc } from "./session-meta.js";
 function displayName(meta, id) {
     return meta?.name ?? meta?.autoName ?? `Conversation ${id}`;
 }
+/** Collect every loaded notifier with its contributing extension's host. */
+export function collectTargets(ctx) {
+    const targets = [];
+    for (const binding of ctx.opened.notifierBindings) {
+        // The Task 2 ext-route host semantics: the captured seam host,
+        // cast across the not-yet-bridged members.
+        const host = ctx.opened.seamHosts.get(binding.extension);
+        for (const notifier of binding.notifiers) {
+            targets.push({ extension: binding.extension, notifier, host });
+        }
+    }
+    return targets;
+}
+/** Enqueue one per-recipient event through every notifier (never awaited). */
+export function deliverEvent(ctx, targets, event) {
+    for (const target of targets) {
+        // Fire-and-forget per transport call: one notifier's failure or
+        // hang neither blocks nor loses the others' deliveries.
+        void ctx.opened.eventBus.runBounded(`notifier ${target.extension}.${target.notifier.name}`, () => target.notifier.notify(event, {
+            host: target.host,
+        }));
+    }
+}
 /**
  * Start the notifications surface. Returns its unsubscribe (the server
  * never calls it today — the surface rides the process lifetime — but
@@ -48,15 +71,7 @@ function displayName(meta, id) {
  */
 export function startNotifications(ctx) {
     const { opened, config } = ctx;
-    const targets = [];
-    for (const binding of opened.notifierBindings) {
-        // The Task 2 ext-route host semantics: the captured seam host,
-        // cast across the not-yet-bridged members.
-        const host = opened.seamHosts.get(binding.extension);
-        for (const notifier of binding.notifiers) {
-            targets.push({ extension: binding.extension, notifier, host });
-        }
-    }
+    const targets = collectTargets(ctx);
     if (targets.length === 0)
         return () => { };
     const bus = opened.eventBus;
@@ -83,13 +98,7 @@ export function startNotifications(ctx) {
                 // the conditional spread keeps the wire shape exact).
                 ...(base.outcome === undefined ? {} : { outcome: base.outcome }),
             };
-            for (const target of targets) {
-                // Fire-and-forget per transport call: one notifier's failure or
-                // hang neither blocks nor loses the others' deliveries.
-                void bus.runBounded(`notifier ${target.extension}.${target.notifier.name}`, () => target.notifier.notify(event, {
-                    host: target.host,
-                }));
-            }
+            deliverEvent(ctx, targets, event);
         }
     };
     /** One conversation's live SessionMeta (undefined on absence or read failure, logged). */
@@ -132,6 +141,12 @@ export function startNotifications(ctx) {
         if (mode === "never")
             return;
         const meta = await metaOf(conversationId);
+        // Curator P5: an internal run never notifies (no "Reply ready" for
+        // curator work). The bus already withholds the host event; this is
+        // the belt-and-braces read-side gate (a hand-published or future
+        // emit path cannot leak the run).
+        if (meta?.internal === true)
+            return;
         if (mode === "cron" && meta?.source !== "cron")
             return;
         if (mode === "unwatched" &&
@@ -204,3 +219,80 @@ export function startNotifications(ctx) {
     });
     return unsubscribe;
 }
+/**
+ * Validate and enqueue one extension notice. The caller's promise resolves
+ * after validation and enqueueing, not after any transport has delivered.
+ */
+export async function notifyExtension(ctx, slug, input) {
+    const users = ctx.opened.identity.users;
+    if (users.isClaimed()) {
+        if (input.user === undefined) {
+            throw new Error("notification user is required when the directory is non-empty");
+        }
+        if (users.get(input.user) === undefined) {
+            throw new Error(`unknown user "${input.user}"`);
+        }
+    }
+    if (typeof input.title !== "string" ||
+        input.title.length < 1 ||
+        input.title.length > 200) {
+        throw new Error("notification title must be 1..200 characters");
+    }
+    if (typeof input.body !== "string" ||
+        input.body.length > 2000) {
+        throw new Error("notification body must be 0..2000 characters");
+    }
+    if (!/^[a-z0-9.-]{1,64}$/.test(input.kind)) {
+        throw new Error("notification kind must be 1..64 characters from [a-z0-9.-]");
+    }
+    if (input.target !== undefined) {
+        if (typeof input.target !== "object" || input.target === null || Array.isArray(input.target)) {
+            throw new Error("notification target must be an object");
+        }
+        const hasView = "view" in input.target;
+        const hasConversation = "conversation" in input.target;
+        if (hasView === hasConversation) {
+            throw new Error("notification target must have exactly one of view or conversation");
+        }
+        if ((hasView && typeof input.target.view !== "string") ||
+            (hasConversation && typeof input.target.conversation !== "number")) {
+            throw new Error("notification target requires a string view or a number conversation");
+        }
+    }
+    let conversationId;
+    let url;
+    if (input.target !== undefined && "view" in input.target) {
+        const view = input.target.view;
+        const binding = ctx.opened.extensionSurfaces.find((candidate) => candidate.extension === slug);
+        const declared = binding?.defs.some((def) => def.placement === "view" && def.id === view);
+        if (declared !== true) {
+            throw new Error(`notification view "${view}" was not declared by extension "${slug}"`);
+        }
+        if (ctx.config.publicUrl !== undefined) {
+            const base = `${ctx.config.publicUrl}/#/ext/${encodeURIComponent(slug)}/` +
+                encodeURIComponent(view);
+            const params = input.target.params ?? {};
+            url = Object.keys(params).length === 0
+                ? base
+                : `${base}?params=${encodeURIComponent(JSON.stringify(params))}`;
+        }
+    }
+    else {
+        conversationId = input.target?.conversation;
+        if (conversationId !== undefined && ctx.config.publicUrl !== undefined) {
+            url = `${ctx.config.publicUrl}/#/c/${conversationId}`;
+        }
+    }
+    const event = {
+        type: "extension",
+        extension: slug,
+        kind: input.kind,
+        conversationId,
+        jobId: undefined,
+        user: input.user,
+        title: input.title,
+        body: input.body,
+        ...(url === undefined ? {} : { url }),
+    };
+    deliverEvent(ctx, collectTargets(ctx), event);
+}

package/dist/server/routes/jobs.js

@@ -212,6 +212,37 @@ export function registerJobRoutes(app, ctx) {
             return await domainError(reply, error);
         }
     });
+    // POST /v1/jobs/:id/state/reset — write access; any live job source.
+    // The job's definition and history stay intact; only its persistent
+    // state folder is removed. Unlike delete/transfer/reconcile cleanup,
+    // an explicit reset surfaces a failed removal to the caller.
+    app.post("/v1/jobs/:id/state/reset", async (request, reply) => {
+        const { id } = request.params;
+        const wire = await jobs.get(id);
+        if (wire === undefined) {
+            return await deny(reply, "job_not_found");
+        }
+        const access = accessOf(accessPrincipal(request), resourceOf(wire));
+        if (access === "none") {
+            return await deny(reply, "job_not_found");
+        }
+        if (access === "read") {
+            return await deny(reply, "forbidden");
+        }
+        try {
+            await jobs.resetState(id);
+            return await reply.code(204).send();
+        }
+        catch (error) {
+            if (error instanceof JobNotFoundError) {
+                return await deny(reply, "job_not_found");
+            }
+            return await reply.code(500).send({
+                error: "state_reset_failed",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
     // POST /v1/jobs/:id/run — write access; fires now (overlap honored).
     // A LIVE record is required (like PATCH/DELETE): a retired job's
     // revision never satisfies run-now — 404, never fireJob's blocked-200

package/dist/server/routes/meta.js

@@ -178,8 +178,8 @@ export function registerMetaRoutes(app, ctx) {
     // templates appear the moment their files land, no reload command. The
     // core + extension halves remain boot constants; see `commands.ts` for
     // the scope rulings.
-    app.get("/v1/commands", async () => {
-        // The workspace root (the first of the three) reads through a
+    app.get("/v1/commands", async (request) => {
+        // The workspace root (the first of the four) reads through a
         // workspace env, exactly like skill discovery at generation time;
         // the catalog scan uses the root conversation's env — the static
         // workspace every conversation resolves to today.
@@ -188,7 +188,12 @@ export function registerMetaRoutes(app, ctx) {
         if (env === undefined) {
             throw new Error("envBuilder returned no ExecutionEnv");
         }
-        const skills = await listSkills(env, BACKGROUND_CONTEXT, expansion.skills);
+        // Curator A3: learned skills are the CALLER's — a user's `/skill:`
+        // menu shows their own learned skills and nobody else's (an
+        // unidentified caller sees none).
+        const skills = await listSkills(env, BACKGROUND_CONTEXT, expansion.skills, {
+            owner: request.principal.user,
+        });
         const templates = expandableTemplates(await discoverTemplates(env, BACKGROUND_CONTEXT, expansion.templates), expansion.commandNames());
         return {
             commands: [

package/dist/server/routes/submissions.js

@@ -46,6 +46,11 @@ export function registerSubmissionRoutes(app, ctx) {
                 ...(body.requestId === undefined
                     ? {}
                     : { requestId: String(body.requestId) }),
+                // Attribution (curator P1): the resolved principal's user is
+                // the input's author; an unidentified caller records nothing.
+                ...(request.principal.user === undefined
+                    ? {}
+                    : { user: request.principal.user }),
                 ...(body.whenBusy === undefined ? {} : { whenBusy: body.whenBusy }),
                 ...(request.query?.waitMs ===
                     undefined

package/dist/server/routes/surfaces.js

@@ -508,7 +508,9 @@ export function registerSurfaceRoutes(app, ctx) {
         if (chatActionStartsTurn(block.tree, body.action)) {
             const answerPayload = (body.payload ?? null);
             const wrapped = { ok: true, rev: block.state.rev };
-            await answerBlock(ctx, id, entryId, body.action, answerPayload, actionId);
+            await answerBlock(ctx, id, entryId, body.action, answerPayload, actionId, 
+            // The acting user authors the answer turn (curator P1).
+            request.principal.user);
             if (actionId !== undefined) {
                 ctx.surfaces.chatDedupRecord(actionId, address, fingerprint, wrapped);
             }

package/dist/server/routes/users.js

@@ -16,6 +16,7 @@ import { withClaimLock } from "../auth/claim-lock.js";
 import { effectiveAdmin, storedGroups } from "../../harness/identity/groups.js";
 import { transferOwnership } from "../ownership.js";
 import { validateGrantPath } from "../../sandbox/grants.js";
+import { removeUserCuration } from "../../curation/deletion.js";
 /** The wire form of one directory user. `admin` stays the STORED flag;
  * `groupAdmin` is DERIVED from stored groups and retained for one release
  * so the users UI keeps rendering. */
@@ -265,6 +266,12 @@ export function registerUserRoutes(app, ctx) {
         // §10.6 step 5: data/state stay for the recipient; core owns only
         // the departing user's credentials, settings, and every cache slug.
         await ctx.opened.extensionStores.removeUserData(user);
+        // Curator A10 (P2): the departing user's learned skills and curation
+        // state are REMOVED, never transferred — a skill distilled from
+        // their conversations can carry their paths and preferences, so it
+        // must not load for the recipient. In-flight curator runs fail
+        // closed through the stores' user-exists gate (nothing recreated).
+        await removeUserCuration(ctx.managedPaths.userAreas(user));
         return await reply.code(204).send();
     });
 }

package/dist/server/schema-fixture.js

@@ -336,6 +336,174 @@ export const VIEW_SCHEMA = {
                                                         }
                                                     }
                                                 },
+                                                {
+                                                    "kind": "object",
+                                                    "fields": {
+                                                        "name": {
+                                                            "kind": "string"
+                                                        },
+                                                        "description": {
+                                                            "kind": "string"
+                                                        },
+                                                        "parameters": {
+                                                            "kind": "object",
+                                                            "fields": {
+                                                                "type": {
+                                                                    "kind": "string"
+                                                                },
+                                                                "required": {
+                                                                    "kind": "array",
+                                                                    "variants": [
+                                                                        {
+                                                                            "kind": "string"
+                                                                        }
+                                                                    ]
+                                                                },
+                                                                "properties": {
+                                                                    "kind": "object",
+                                                                    "fields": {
+                                                                        "action": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "anyOf": {
+                                                                                    "kind": "array",
+                                                                                    "variants": [
+                                                                                        {
+                                                                                            "kind": "object",
+                                                                                            "fields": {
+                                                                                                "type": {
+                                                                                                    "kind": "string"
+                                                                                                },
+                                                                                                "const": {
+                                                                                                    "kind": "string"
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    ]
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "name": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "file_path": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "content": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "old_text": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "new_text": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "absorbed_into": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "reason": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "overlay_root": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "anyOf": {
+                                                                                    "kind": "array",
+                                                                                    "variants": [
+                                                                                        {
+                                                                                            "kind": "object",
+                                                                                            "fields": {
+                                                                                                "type": {
+                                                                                                    "kind": "string"
+                                                                                                },
+                                                                                                "const": {
+                                                                                                    "kind": "string"
+                                                                                                }
+                                                                                            }
+                                                                                        }
+                                                                                    ]
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        },
+                                                                        "remove": {
+                                                                            "kind": "object",
+                                                                            "fields": {
+                                                                                "type": {
+                                                                                    "kind": "string"
+                                                                                },
+                                                                                "description": {
+                                                                                    "kind": "string"
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                    }
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                },
                                                 {
                                                     "kind": "object",
                                                     "fields": {