dna-sdk 0.6.0 → 0.8.0

package/dist/emit/agentFramework.d.ts

@@ -0,0 +1,16 @@
+import type { EmitContext, EmitResult, EmitterPort } from "./index.js";
+/** `concierge-grounded` → `ConciergeGrounded`. */
+export declare function camel(name: string): string;
+/** Split a DNA model coordinate into agent-framework `{id, provider}`. */
+export declare function splitModel(model: string | null, providerHint?: string | null): {
+    id: string;
+    provider: string;
+} | null;
+export declare class AgentFrameworkEmitter implements EmitterPort {
+    readonly target = "agent-framework";
+    readonly fileExtension = "agent.yaml";
+    /** The PURE de-para: {@link EmitContext} → the PromptAgent object. Field
+     *  order is intentional and preserved by js-yaml (insertion order). */
+    toPromptAgent(ctx: EmitContext): Record<string, unknown>;
+    emit(ctx: EmitContext): EmitResult;
+}

package/dist/emit/agentFramework.js

@@ -0,0 +1,127 @@
+/**
+ * DNA → Microsoft **agent-framework** emitter (TS twin of python
+ * `dna.emit.agent_framework`). Materializes an {@link EmitContext} into the
+ * declarative `PromptAgent` YAML that `agent-framework-declarative`'s
+ * `AgentFactory` loads.
+ *
+ * The de-para (DNA field → PromptAgent field):
+ *   metadata.name                     -> name         (CamelCased id)
+ *   metadata.description              -> description
+ *   Soul + guardrails + instruction   -> instructions (flat — kernel-composed)
+ *   spec.model (or Genome default_llm)-> model.{id, provider}
+ *   spec.tools[] (Tool Kind surfaces) -> tools[] (kind: function)
+ *   spec.output_schema                -> outputSchema (only when present)
+ *
+ * `toPromptAgent` is the PURE de-para and is parity-critical: it must build the
+ * SAME object the Python `to_prompt_agent` builds from the same context.
+ */
+import yaml from "js-yaml";
+/** DNA provider token → agent-framework `model.provider` value. Unknown tokens
+ *  pass through unchanged so a future provider needs no code change. */
+const PROVIDER_MAP = {
+    azure: "AzureOpenAI",
+    azureopenai: "AzureOpenAI",
+    azure_openai: "AzureOpenAI",
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    foundry: "AzureAIFoundry",
+    azureaifoundry: "AzureAIFoundry",
+};
+/** Bare model with no provider token and no `--provider` → AzureOpenAI (the
+ *  provider the spike proved). Documented default, never silently wrong. */
+const DEFAULT_PROVIDER = "AzureOpenAI";
+/** `concierge-grounded` → `ConciergeGrounded`. */
+export function camel(name) {
+    return String(name)
+        .replace(/_/g, "-")
+        .split("-")
+        .filter(Boolean)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join("");
+}
+/** Split a DNA model coordinate into agent-framework `{id, provider}`. */
+export function splitModel(model, providerHint) {
+    if (!model)
+        return null;
+    let token = null;
+    let ident = model;
+    for (const sep of [":", "/"]) {
+        const i = model.indexOf(sep);
+        if (i >= 0) {
+            token = model.slice(0, i);
+            ident = model.slice(i + 1);
+            break;
+        }
+    }
+    let provider;
+    if (providerHint)
+        provider = providerHint;
+    else if (token)
+        provider = PROVIDER_MAP[token.trim().toLowerCase()] ?? token;
+    else
+        provider = DEFAULT_PROVIDER;
+    return { id: ident.trim(), provider };
+}
+function emitTools(tools) {
+    return tools.map((t) => {
+        const entry = {
+            name: t.name,
+            kind: "function", // AgentSchema function-tool kind (NOT `type`)
+            description: t.description ?? "",
+        };
+        if (t.parameters && Object.keys(t.parameters).length > 0) {
+            entry.parameters = t.parameters;
+        }
+        return entry;
+    });
+}
+export class AgentFrameworkEmitter {
+    target = "agent-framework";
+    fileExtension = "agent.yaml";
+    /** The PURE de-para: {@link EmitContext} → the PromptAgent object. Field
+     *  order is intentional and preserved by js-yaml (insertion order). */
+    toPromptAgent(ctx) {
+        const providerHint = ctx.options?.provider ?? null;
+        const doc = { kind: "Prompt", name: camel(ctx.name) };
+        if (ctx.description)
+            doc.description = ctx.description;
+        const model = splitModel(ctx.model, providerHint);
+        if (model)
+            doc.model = model;
+        if (ctx.tools.length > 0)
+            doc.tools = emitTools(ctx.tools);
+        doc.instructions = ctx.instructions; // verbatim — the byte-equal gate
+        if (ctx.outputSchema)
+            doc.outputSchema = ctx.outputSchema;
+        return doc;
+    }
+    emit(ctx) {
+        const promptAgent = this.toPromptAgent(ctx);
+        const artifact = yaml.dump(promptAgent, { sortKeys: false, lineWidth: -1 });
+        const losses = [
+            "composition structure — Soul reuse + wired Guardrails flatten to one " +
+                "`instructions` string (no `soul:`/`guardrails:` slot in a PromptAgent)",
+            "tenant overlay — a per-tenant persona without a fork has no PromptAgent field",
+            "eval-as-contract — prompt invariants (EvalCases) have no PromptAgent slot",
+        ];
+        if (ctx.model === null) {
+            losses.push("model unbound in DNA and none supplied — emitted PromptAgent has no " +
+                "`model:` block; pass provider/model or set spec.model / Genome default_llm");
+        }
+        const mapping = {
+            "metadata.name": "name (CamelCase)",
+            "metadata.description": "description",
+            "buildPrompt (Soul+guardrails+instruction)": "instructions",
+            "spec.model / Genome.default_llm": "model.{id,provider}",
+            "spec.tools[] (Tool Kind)": "tools[] (kind: function)",
+            "spec.output_schema": "outputSchema",
+        };
+        return {
+            artifact,
+            target: this.target,
+            filename: `${ctx.name}.${this.fileExtension}`,
+            losses,
+            mapping,
+        };
+    }
+}

package/dist/emit/bedrock.d.ts

@@ -0,0 +1,47 @@
+/**
+ * DNA → **Amazon Bedrock Agent** emitter (TS twin of python
+ * `dna.emit.bedrock`). Materializes an {@link EmitContext} into an AWS
+ * **CloudFormation** template that declares an `AWS::Bedrock::Agent` resource —
+ * the managed, declarative Bedrock Agents service. The SECOND runtime the SAME
+ * DNA source emits to (the first is Microsoft agent-framework): the portability
+ * proof — author once, emit per runtime.
+ *
+ * Why Bedrock **Agents** (not Strands / AgentCore): only Bedrock Agents has a
+ * published *declarative* schema (`Instruction`, `FoundationModel`,
+ * `ActionGroups` with a `FunctionSchema`) that maps field-for-field from a DNA
+ * agent. Emitting a CloudFormation template gives a lintable, deployable artifact
+ * that needs no AWS credential to produce or validate structurally.
+ *
+ * The de-para (DNA field → CloudFormation `AWS::Bedrock::Agent` field):
+ *   metadata.name                     -> Resources.<Camel>Agent.Properties.AgentName
+ *   metadata.description              -> Properties.Description        (when present)
+ *   Soul + guardrails + instruction   -> Properties.Instruction        (flat, BYTE-EQUAL)
+ *   spec.model (or Genome default_llm)-> Properties.FoundationModel     (provider token stripped)
+ *   spec.tools[] (Tool Kind surfaces) -> Properties.ActionGroups[0].FunctionSchema.Functions[]
+ *
+ * `toTemplate` is the PURE de-para and is parity-critical: it must build the SAME
+ * object the Python `to_template` builds from the same context.
+ */
+import type { EmitContext, EmitResult, EmitterPort } from "./index.js";
+/** `concierge-grounded` → `ConciergeGrounded` (a valid CFN logical id). */
+export declare function camel(name: string): string;
+/** Project a DNA model coordinate → a Bedrock `FoundationModel` id. Bedrock
+ *  encodes the provider inside the id (`anthropic.claude-v2`), so a DNA
+ *  `prov:model` / `prov/model` provider token is dropped; a bare coordinate
+ *  passes through unchanged. */
+export declare function bedrockModelId(model: string | null): string | null;
+/** Project a Tool's input JSON Schema → Bedrock `Function.Parameters`
+ *  (`{name: {Type, Description, Required}}`). Returns the map + whether any type
+ *  was coerced (for the loss report). */
+export declare function emitParameters(inputSchema: Record<string, unknown>): {
+    params: Record<string, unknown>;
+    coerced: boolean;
+};
+export declare class BedrockEmitter implements EmitterPort {
+    readonly target = "bedrock";
+    readonly fileExtension = "bedrock.json";
+    /** The PURE de-para: {@link EmitContext} → the CloudFormation object. Field
+     *  order is intentional and preserved by JSON.stringify (insertion order). */
+    toTemplate(ctx: EmitContext): Record<string, unknown>;
+    emit(ctx: EmitContext): EmitResult;
+}

package/dist/emit/bedrock.js

@@ -0,0 +1,169 @@
+/** Bedrock `ParameterDetail.Type` allowed values. A JSON-Schema type outside
+ *  this set (notably `object`) is coerced to `string` (the depth loss). */
+const BEDROCK_PARAM_TYPES = new Set(["string", "number", "integer", "boolean", "array"]);
+/** CloudFormation template format version — the stable, only value. */
+const CFN_VERSION = "2010-09-09";
+/** DNA provider tokens (the `prov:model` / `prov/model` prefixes DNA authors
+ *  use). Stripped to expose the bare model id. Bedrock-native provider prefixes
+ *  (anthropic./amazon./…) use a DOT and are NOT here, so a real Bedrock id (incl.
+ *  a `:0` version suffix) passes through. */
+const DNA_PROVIDER_TOKENS = new Set([
+    "azure", "azureopenai", "azure_openai", "openai", "foundry", "azureaifoundry",
+    "vertex", "google", "gemini",
+]);
+/** `concierge-grounded` → `ConciergeGrounded` (a valid CFN logical id). */
+export function camel(name) {
+    return String(name)
+        .replace(/_/g, "-")
+        .split("-")
+        .filter(Boolean)
+        .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+        .join("");
+}
+/** Project a DNA model coordinate → a Bedrock `FoundationModel` id. Bedrock
+ *  encodes the provider inside the id (`anthropic.claude-v2`), so a DNA
+ *  `prov:model` / `prov/model` provider token is dropped; a bare coordinate
+ *  passes through unchanged. */
+export function bedrockModelId(model) {
+    if (!model)
+        return null;
+    const ident = model.trim();
+    if (ident.toLowerCase().startsWith("arn:"))
+        return ident; // ARN — never split.
+    const slash = ident.indexOf("/");
+    if (slash >= 0)
+        return ident.slice(slash + 1).trim(); // DNA slash coordinate.
+    const colon = ident.indexOf(":");
+    if (colon >= 0) {
+        const token = ident.slice(0, colon).trim().toLowerCase();
+        if (DNA_PROVIDER_TOKENS.has(token))
+            return ident.slice(colon + 1).trim();
+    }
+    return ident; // bare / Bedrock-native id (keeps any `:version`).
+}
+/** Project a Tool's input JSON Schema → Bedrock `Function.Parameters`
+ *  (`{name: {Type, Description, Required}}`). Returns the map + whether any type
+ *  was coerced (for the loss report). */
+export function emitParameters(inputSchema) {
+    const props = inputSchema?.properties;
+    if (!props || typeof props !== "object" || Object.keys(props).length === 0) {
+        return { params: {}, coerced: false };
+    }
+    const required = Array.isArray(inputSchema.required) ? inputSchema.required : [];
+    const requiredSet = new Set(required);
+    const out = {};
+    let coerced = false;
+    for (const [pname, raw] of Object.entries(props)) {
+        const pschema = (raw && typeof raw === "object" ? raw : {});
+        const jtype = pschema.type ?? "string";
+        let btype;
+        if (BEDROCK_PARAM_TYPES.has(jtype)) {
+            btype = jtype;
+        }
+        else {
+            btype = "string"; // object / unknown → flatten to string (recorded loss)
+            coerced = true;
+        }
+        const detail = { Type: btype };
+        if (pschema.description)
+            detail.Description = pschema.description;
+        detail.Required = requiredSet.has(pname);
+        out[pname] = detail;
+    }
+    return { params: out, coerced };
+}
+/** Project the agent's tools → a single Bedrock action group. The executor is
+ *  `CustomControl: RETURN_CONTROL` — Bedrock returns the tool call to the CALLER
+ *  (the faithful mapping for DNA's client-side tools; no Lambda ARN needed). */
+function emitActionGroups(ctx) {
+    const functions = [];
+    let anyCoerced = false;
+    for (const t of ctx.tools) {
+        const fn = { Name: t.name };
+        if (t.description)
+            fn.Description = t.description;
+        const { params, coerced } = emitParameters((t.parameters ?? {}));
+        anyCoerced = anyCoerced || coerced;
+        if (Object.keys(params).length > 0)
+            fn.Parameters = params;
+        functions.push(fn);
+    }
+    const group = {
+        ActionGroupName: `${ctx.name}-actions`,
+        Description: `DNA-emitted tools for agent ${ctx.name}`,
+        ActionGroupExecutor: { CustomControl: "RETURN_CONTROL" },
+        FunctionSchema: { Functions: functions },
+    };
+    return { groups: [group], coerced: anyCoerced };
+}
+export class BedrockEmitter {
+    target = "bedrock";
+    fileExtension = "bedrock.json";
+    /** The PURE de-para: {@link EmitContext} → the CloudFormation object. Field
+     *  order is intentional and preserved by JSON.stringify (insertion order). */
+    toTemplate(ctx) {
+        const logicalId = `${camel(ctx.name)}Agent`;
+        const props = { AgentName: ctx.name };
+        if (ctx.description)
+            props.Description = ctx.description;
+        const modelId = bedrockModelId(ctx.model);
+        if (modelId)
+            props.FoundationModel = modelId;
+        props.Instruction = ctx.instructions; // verbatim — the byte-equal gate
+        if (ctx.tools.length > 0)
+            props.ActionGroups = emitActionGroups(ctx).groups;
+        props.AutoPrepare = true;
+        return {
+            AWSTemplateFormatVersion: CFN_VERSION,
+            Description: `DNA-emitted Amazon Bedrock Agent: ${ctx.name}`,
+            Resources: {
+                [logicalId]: { Type: "AWS::Bedrock::Agent", Properties: props },
+            },
+        };
+    }
+    emit(ctx) {
+        const template = this.toTemplate(ctx);
+        const artifact = JSON.stringify(template, null, 2) + "\n";
+        const losses = [
+            "composition structure — Soul reuse + wired Guardrails flatten to one " +
+                "`Instruction` string (Bedrock `GuardrailConfiguration` is an " +
+                "ID-referenced Bedrock Guardrail, not DNA's composed guardrails)",
+            "tenant overlay — a per-tenant persona without a fork has no Bedrock Agent field",
+            "eval-as-contract — prompt invariants (EvalCases) have no Bedrock slot",
+        ];
+        if (ctx.tools.length > 0) {
+            losses.push("tool parameter depth — Bedrock `ParameterDetail` is a flat " +
+                "{Type, Description, Required} map (Type ∈ string|number|integer|" +
+                "boolean|array); JSON-Schema `default`, `enum`, nested object " +
+                "`properties`, and array `items` typing are dropped");
+        }
+        if (ctx.outputSchema) {
+            losses.push("output_schema — Bedrock Agent has no structured-response / " +
+                "output-schema field; the agent's typed output contract is dropped");
+        }
+        if (ctx.model === null) {
+            losses.push("model unbound in DNA and none supplied — emitted template has no " +
+                "`FoundationModel`; pass provider/model or set spec.model / Genome default_llm");
+        }
+        else {
+            losses.push("model coordinate — a DNA `azure/openai` coordinate is not a Bedrock " +
+                "foundation-model id; `FoundationModel` needs a Bedrock model id or " +
+                "inference-profile ARN, plus an `AgentResourceRoleArn` at deploy");
+        }
+        const mapping = {
+            "metadata.name": "Resources.<id>Agent.Properties.AgentName",
+            "metadata.description": "Properties.Description",
+            "buildPrompt (Soul+guardrails+instruction)": "Properties.Instruction (byte-equal)",
+            "spec.model / Genome.default_llm": "Properties.FoundationModel",
+            "spec.tools[] (Tool Kind)": "Properties.ActionGroups[].FunctionSchema.Functions[]",
+            "Tool.input_schema.properties": "Function.Parameters{Type,Description,Required}",
+        };
+        return {
+            artifact,
+            target: this.target,
+            filename: `${ctx.name}.${this.fileExtension}`,
+            losses,
+            mapping,
+        };
+    }
+}

package/dist/emit/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * `emit` — the vendor-neutral EMITTER layer (TS twin of python `dna.emit`).
+ *
+ * DNA authors an agent ONCE — a persona (Soul), an instruction (Agent), wired
+ * Guardrails, and Tools — as declarative Kinds. This module materializes that
+ * one neutral definition into the NATIVE artifact each runtime framework
+ * consumes. The concrete first step of "DNA as the Terraform of agents": author
+ * once, emit per runtime, swap runtimes without rewriting the agent.
+ *
+ * Parity: the pure de-para (`toPromptAgent` in `agentFramework.ts`) mirrors the
+ * Python emitter field-for-field; the serialization (js-yaml vs PyYAML) is a
+ * rendering detail, so the parity contract is the emitted OBJECT, not the bytes.
+ *
+ * Shape: {@link EmitContext} (runtime-agnostic view of a composed agent) →
+ * {@link EmitterPort} (a target) → {@link EmitResult} (artifact + honest
+ * `losses`). {@link registerEmitter}/{@link getEmitter}/{@link availableTargets}
+ * are the pluggable registry — a new target is a class + one register call.
+ */
+import type { ManifestInstance } from "../kernel/instance.js";
+/** Runtime-agnostic view of ONE composed DNA agent. */
+export interface EmitContext {
+    /** The DNA agent slug (`metadata.name`). */
+    name: string;
+    /** `metadata.description`, or "". */
+    description: string;
+    /** DNA-composed system prompt (Soul + guardrails + instruction, flat). The
+     *  byte-equal gate: an emitter MUST carry it verbatim. */
+    instructions: string;
+    /** Raw DNA model coordinate (`openai:gpt-4o-mini` / `azure/gpt-4o` / bare), or
+     *  null when the DNA leaves the model unbound. */
+    model: string | null;
+    /** Resolved tool surfaces (`spec.tools` → Tool Kind). */
+    tools: EmitTool[];
+    /** Optional response JSON Schema (`spec.output_schema`), or null. */
+    outputSchema: Record<string, unknown> | null;
+    /** Scope the agent was composed from (provenance). */
+    scope: string | null;
+    /** Per-emitter hints (e.g. a `--provider` override). */
+    options: Record<string, unknown>;
+}
+export interface EmitTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+/** The emitted native artifact + an honest account of the de-para. */
+export interface EmitResult {
+    /** The serialized native artifact. */
+    artifact: string;
+    /** The target runtime id. */
+    target: string;
+    /** Suggested filename. */
+    filename: string;
+    /** DNA axes with NO slot in this target — what did NOT survive the emit. */
+    losses: string[];
+    /** Field-level de-para (`dnaField -> targetField`). */
+    mapping: Record<string, string>;
+}
+/** A runtime emitter — pure: reads an {@link EmitContext}, returns an
+ *  {@link EmitResult}. No kernel I/O, no network. */
+export interface EmitterPort {
+    readonly target: string;
+    readonly fileExtension: string;
+    emit(ctx: EmitContext): EmitResult;
+}
+export declare class EmitError extends Error {
+}
+export declare class UnknownTarget extends EmitError {
+    readonly target: string;
+    readonly available: string[];
+    constructor(target: string, available: string[]);
+}
+/** Register an emitter under its `target` (last registration wins). */
+export declare function registerEmitter(emitter: EmitterPort): EmitterPort;
+/** Look up a registered emitter or throw {@link UnknownTarget}. */
+export declare function getEmitter(target: string): Promise<EmitterPort>;
+/** Sorted list of registered target ids. */
+export declare function availableTargets(): Promise<string[]>;
+export interface BuildEmitContextOpts {
+    model?: string | null;
+    provider?: string | null;
+}
+/** Compose a DNA agent through the kernel and project it to an
+ *  {@link EmitContext}. `mi` is a live ManifestInstance. */
+export declare function buildEmitContext(mi: ManifestInstance, agent: string, opts?: BuildEmitContextOpts): Promise<EmitContext>;
+/** Compose `agent` from `mi` and emit it for `target`. */
+export declare function emitAgent(mi: ManifestInstance, agent: string, target: string, opts?: BuildEmitContextOpts): Promise<EmitResult>;

package/dist/emit/index.js

@@ -0,0 +1,97 @@
+import { ToolLibrary } from "../tools.js";
+export class EmitError extends Error {
+}
+export class UnknownTarget extends EmitError {
+    target;
+    available;
+    constructor(target, available) {
+        super(`no emitter registered for target '${target}'; available: ` +
+            (available.join(", ") || "(none)"));
+        this.target = target;
+        this.available = available;
+        this.name = "UnknownTarget";
+    }
+}
+// ── registry ──────────────────────────────────────────────────────────────
+const EMITTER_REGISTRY = new Map();
+let builtinsWired = false;
+async function ensureBuiltins() {
+    if (builtinsWired)
+        return;
+    builtinsWired = true;
+    const { AgentFrameworkEmitter } = await import("./agentFramework.js");
+    const { BedrockEmitter } = await import("./bedrock.js");
+    for (const e of [new AgentFrameworkEmitter(), new BedrockEmitter()]) {
+        if (!EMITTER_REGISTRY.has(e.target))
+            EMITTER_REGISTRY.set(e.target, e);
+    }
+}
+/** Register an emitter under its `target` (last registration wins). */
+export function registerEmitter(emitter) {
+    EMITTER_REGISTRY.set(emitter.target, emitter);
+    return emitter;
+}
+/** Look up a registered emitter or throw {@link UnknownTarget}. */
+export async function getEmitter(target) {
+    await ensureBuiltins();
+    const e = EMITTER_REGISTRY.get(target);
+    if (!e)
+        throw new UnknownTarget(target, await availableTargets());
+    return e;
+}
+/** Sorted list of registered target ids. */
+export async function availableTargets() {
+    await ensureBuiltins();
+    return [...EMITTER_REGISTRY.keys()].sort();
+}
+/** Compose a DNA agent through the kernel and project it to an
+ *  {@link EmitContext}. `mi` is a live ManifestInstance. */
+export async function buildEmitContext(mi, agent, opts = {}) {
+    const doc = mi.findAgent(agent);
+    if (!doc) {
+        throw new EmitError(`agent '${agent}' not found in scope '${mi.scope ?? "?"}'`);
+    }
+    const spec = (doc.spec ?? {});
+    const meta = (doc.metadata ?? {});
+    const description = meta.description ?? "";
+    const instructions = await mi.buildPrompt({ agent });
+    let resolvedModel = opts.model ?? spec.model ?? null;
+    if (!resolvedModel) {
+        const root = mi.root;
+        const rootSpec = (root?.spec ?? {});
+        resolvedModel = rootSpec.default_llm ?? null;
+    }
+    const tools = resolveTools(mi, spec);
+    const outputSchema = spec.output_schema ?? null;
+    return {
+        name: doc.name ?? agent,
+        description,
+        instructions,
+        model: resolvedModel,
+        tools,
+        outputSchema,
+        scope: mi.scope ?? null,
+        options: opts.provider ? { provider: opts.provider } : {},
+    };
+}
+function resolveTools(mi, spec) {
+    const names = spec.tools;
+    if (!names || names.length === 0)
+        return [];
+    const lib = new ToolLibrary(mi);
+    return names.map((name) => {
+        const surface = lib.get(name); // throws ToolNotFound (fail-loud)
+        return {
+            name,
+            description: surface.description,
+            parameters: { ...surface.parameters },
+        };
+    });
+}
+// ── high-level surface ──────────────────────────────────────────────────────
+/** Compose `agent` from `mi` and emit it for `target`. */
+export async function emitAgent(mi, agent, target, opts = {}) {
+    const emitter = await getEmitter(target);
+    const ctx = await buildEmitContext(mi, agent, opts);
+    return emitter.emit(ctx);
+}

package/dist/extensions/research.js

@@ -101,6 +101,14 @@ class ResearchKind extends KindBase {
                     items: { type: "string" },
                     default: [],
                 },
+                cited_by: {
+                    type: "array",
+                    items: { type: "string" },
+                    default: [],
+                    description: "Kind/name of docs that cite this Research as a grounding source. " +
+                        "Auto-maintained by `dna sdlc cite Research/<name> --from <Kind>/<name>` " +
+                        "— don't author by hand.",
+                },
                 findings: {
                     type: "array",
                     items: {

package/dist/index.d.ts

@@ -26,6 +26,10 @@ export { AgentNotFound, ToolNotFound, UnknownLayout } from "./kernel/errors.js";
 export { PromptLibrary, loadPrompts } from "./prompts.js";
 export { ToolLibrary, loadTools } from "./tools.js";
 export type { ToolSurface } from "./tools.js";
+export { emitAgent, buildEmitContext, registerEmitter, getEmitter, availableTargets, EmitError, UnknownTarget, } from "./emit/index.js";
+export type { EmitContext, EmitResult, EmitTool, EmitterPort, BuildEmitContextOpts, } from "./emit/index.js";
+export { AgentFrameworkEmitter } from "./emit/agentFramework.js";
+export { BedrockEmitter } from "./emit/bedrock.js";
 export type { LoadPromptsOptions } from "./prompts.js";
 export { anchorScopesRoot, PackageScopeNotFound, DEFAULT_SUBPATH } from "./package-scope.js";
 export { loadConfig, findConfig, CONFIG_FILENAME } from "./config.js";

package/dist/index.js

@@ -30,6 +30,9 @@ export { createKernelWithBuiltins, quickInstance, createRuntimeWithBuiltins, qui
 export { AgentNotFound, ToolNotFound, UnknownLayout } from "./kernel/errors.js";
 export { PromptLibrary, loadPrompts } from "./prompts.js";
 export { ToolLibrary, loadTools } from "./tools.js";
+export { emitAgent, buildEmitContext, registerEmitter, getEmitter, availableTargets, EmitError, UnknownTarget, } from "./emit/index.js";
+export { AgentFrameworkEmitter } from "./emit/agentFramework.js";
+export { BedrockEmitter } from "./emit/bedrock.js";
 export { anchorScopesRoot, PackageScopeNotFound, DEFAULT_SUBPATH } from "./package-scope.js";
 export { loadConfig, findConfig, CONFIG_FILENAME } from "./config.js";
 export { sourceFromUrl, resolveDefaultFsUrl, UnsupportedSourceScheme } from "./adapters/source-url.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dna-sdk",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "DNA — Domain Notation of Anything (TypeScript SDK)",
   "type": "module",
   "license": "MIT",