@agentproto/app-kit 0.2.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,142 @@
+# @agentproto/app-kit
+
+Declare one or more **agents** (with their system prompts) and the **workflows**
+they run in one TypeScript module, then import them anywhere.
+
+A thin umbrella over AIP-42 [`defineAgent`](../agent) + AIP-15
+[`defineWorkflow`](../workflow). It doesn't re-validate their fields — those ran
+when you built the handles — it validates the *coupling* and gives you two ways
+to consume the bundle: runnable Mastra agents, or emitted `.md` manifests.
+
+```ts
+import { defineApp } from "@agentproto/app-kit"
+import { defineAgent } from "@agentproto/agent"
+import { defineWorkflow } from "@agentproto/workflow"
+
+export const reviewApp = defineApp({
+  agents: [
+    {
+      agent: defineAgent({
+        schema: "agent/v1",
+        id: "@agentik/reviewer",
+        description: "Reviews a PR diff and reports findings.",
+        model: "claude-sonnet-5",
+        boundaries: ["Never run gh pr merge"],
+        workflows: [{ ref: "review-and-fix" }], // ← must match a bundled workflow
+      }),
+      body: `You are a rigorous PR reviewer. Report findings; change nothing.`,
+    },
+    // body optional — omit it and the prompt composes from the agent's
+    // persona / boundaries / traits.
+    { agent: defineAgent({ schema: "agent/v1", id: "fixer", description: "Applies fixes.", model: "claude-sonnet-5", workflows: [{ ref: "review-and-fix" }] }) },
+  ],
+  workflows: [
+    defineWorkflow({
+      id: "review-and-fix",
+      name: "Review and fix",
+      description: "Read the diff, report findings.",
+      version: "0.1.0",
+      inputs: {},
+      outputs: {},
+      steps: [{ id: "review", kind: "tool", tool: "read_diff" }],
+    }),
+  ],
+  attach: [ /* any AIP handle: AIP-6 company, AIP-25 persona, AIP-47 role, policy… */ ],
+  workspace: {                          // ← optional home workspace (AIP-34)
+    id: "@acme/reviewers",
+    name: "Acme Reviewers",
+    owner: { type: "guild", id: "guild_123", slug: "acme" }, // = the tenant
+    // storage defaults to { inline: { provider: "local-fs", config: {} } }
+  },
+})
+```
+
+## The tenant + local storage — it's the workspace, not a folder
+
+An app can declare a home **`workspace`** (AIP-34 `WORKSPACE.md`). Reuse it
+instead of inventing tenant folders, because AIP-34/35 already model both axes:
+
+- **Tenant** = the workspace's `owner` — `{ type: "guild" | "user" | "org", id, slug }`.
+  Not a `tenants/<t>/` path segment; an identity on the manifest.
+- **Local storage** = the AIP-35 `storage` block — `provider: "local-fs"` (also
+  `dev-local`, `local-ide`, `github`, `mastra-s3`, …). Defaults to `local-fs`.
+
+Pass either a `{ id, name, owner, storage? }` **shorthand** (completed with a
+local-fs default + validated by `defineWorkspace`) or a pre-built
+[`defineWorkspace`](../workspace) handle. This is the same workspace model Guilde
+already uses — a guild's `system` workspace mounted at `/.guilde` holding its
+operator / role / skill definitions.
+
+## Where is the system prompt? — it's the `body`
+
+There is **no `systemPrompt` field anywhere in AIP**. An AGENT.md is
+*frontmatter (metadata) + body (the prompt)*, and the frontmatter schema is
+`.strict()` — so `defineAgent` structurally cannot hold prose. The prompt is the
+**body**, and it's optional: omit it and the prompt composes from the agent's
+`persona` (AIP-25), `boundaries`, and `traits` — the same way Guilde assembles an
+operator's prompt from AIP-47 role instructions + persona rather than a stored
+string. `composeInstructions` (in [`@agentproto/mastra`](../mastra)) is the
+assembler.
+
+## The attachment invariant
+
+`defineApp` enforces the coupling: agent ids are unique; every `agent.workflows[]`
+ref must resolve to a bundled workflow; every bundled workflow must be referenced
+by at least one agent. A dangling ref or an orphan workflow throws
+`AppDefinitionError`. `attach` carries any other AIP handle verbatim (structural
+`{ id }`), so a company, persona, or role rides along without app-kit depending
+on each doctype package.
+
+## Consuming a bundle
+
+### `handle.toMastraAgents(resolvers)` — run them
+
+Builds every agent, keyed by id, turning each `body` into a **real Mastra
+`instructions` field** via [`@agentproto/mastra`](../mastra). You supply the
+resolvers (model, tools, memory…).
+
+```ts
+const built = await reviewApp.toMastraAgents({ resolveModel: (ref) => registry.resolve(ref) })
+built["@agentik/reviewer"].agent   // a runnable Mastra Agent
+```
+
+**Use just some of a team.** Pass `only` to build a subset instead of the whole
+app — so a host doesn't pay to build agents it won't run. Unknown ids throw.
+
+```ts
+const built = await reviewApp.toMastraAgents({ resolveModel }, ["@agentik/reviewer"])
+const [reviewer] = reviewApp.pick(["@agentik/reviewer"]) // select without building
+```
+
+`handle.toMastraAgent(resolvers)` is a convenience for single-agent apps (throws
+if the app has more than one). `@mastra/core` is a **peer dependency** — install
+it in the host if you call either. `emit` has no Mastra dependency.
+
+### `handle.emit(dir)` — ship them
+
+Writes the manifests under an **agentproto-owned base** — it doesn't squat the
+shared root `.agents/` convention:
+
+```
+<dir>/WORKSPACE.md                                      (AIP-34 root manifest — only when the app has a workspace)
+<dir>/.agentproto/agents/reviewer/AGENT.md
+<dir>/.agentproto/agents/fixer/AGENT.md
+<dir>/.agentproto/workflows/review-and-fix/WORKFLOW.md   (shared — a workflow may be run by several agents)
+```
+
+The daemon's state root is migrating toward a `tenants/<t>/…` segment
+(AIP-46 / DESIGN.md §9); app-kit will add that segment once the daemon's tenant
+layer lands, rather than inventing the shape ahead of it.
+
+Both are plain markdown: frontmatter = the validated handle, body = the agent's
+`body` (AGENT.md) / the workflow description (WORKFLOW.md). Because a
+`defineWorkflow` handle is pure data, the `WORKFLOW.md` needs no `entry:` module —
+the manifest *is* the workflow, so `loadWorkflowHandle` returns it directly.
+
+## Runtime note
+
+`toMastraAgents` is the path where a `body` becomes a **true** model
+`instructions` field, because that wiring lives in the mastra adapter. The
+generic daemon session-spawn has no system-prompt field today (instructions ride
+in as prepended prompt text for CLI adapters), so an emitted AGENT.md reaches the
+model as a real system prompt only through a mastra-family runtime.

package/dist/define-app.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `defineApp({ agents, workflows, attach })` — bundle one or more AIP-42
+ * agents, the AIP-15 workflows they run, and any other AIP artifacts into
+ * one cross-linked, frozen handle.
+ *
+ * The only new invariant app-kit adds is *attachment*: the agents and the
+ * bundled workflows must reference each other. Everything else (field
+ * validation) already ran when the caller built the handles with
+ * `defineAgent` / `defineWorkflow`, so `defineApp` validates the coupling,
+ * not the fields.
+ *
+ *   - agent ids are unique within the app.
+ *   - every `agent.workflows[]` ref MUST resolve to a bundled workflow id.
+ *   - every bundled workflow MUST be referenced by at least one agent.
+ *
+ * A dangling ref (an agent points at a workflow the app didn't bundle) or
+ * an orphan (a bundled workflow no agent lists) throws — that is what "an
+ * agent attached to its workflows" means, made checkable.
+ */
+import type { AppDefinition, AppHandle, DoctypeHandle } from "./types.js";
+export declare class AppDefinitionError extends Error {
+    constructor(message: string);
+}
+export declare function defineApp(def: AppDefinition): AppHandle;
+export type { DoctypeHandle };
+//# sourceMappingURL=define-app.d.ts.map

package/dist/define-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-app.d.ts","sourceRoot":"","sources":["../src/define-app.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH,OAAO,KAAK,EAEV,aAAa,EACb,SAAS,EACT,aAAa,EAGd,MAAM,YAAY,CAAA;AAInB,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,CAqDvD;AA8GD,YAAY,EAAE,aAAa,EAAE,CAAA"}

package/dist/emit.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `emitApp(app, dir)` — write an app's agents + workflows to disk under an
+ * agentproto-owned base, so the manifests don't squat the shared root
+ * `.agents/` convention:
+ *
+ *   <dir>/WORKSPACE.md                              (when the app has a
+ *                                                    workspace — AIP-34 root
+ *                                                    manifest; owner = tenant)
+ *   <dir>/.agentproto/agents/<id>/AGENT.md         (one per agent)
+ *   <dir>/.agentproto/workflows/<wf.id>/WORKFLOW.md (shared — a workflow may
+ *                                                    be run by several agents)
+ *
+ * The "tenant" isn't a `tenants/<t>/…` path segment — it's the `owner` of
+ * the AIP-34 WORKSPACE.md (guild / user / org), and local storage is its
+ * AIP-35 `storage` block. So there is no bespoke tenant folder to invent.
+ *
+ * Both are plain markdown manifests: frontmatter = the validated handle,
+ * body = the agent's `body` (its system prompt) or the workflow description.
+ * Because a `defineWorkflow` handle is pure data, the WORKFLOW.md needs no
+ * `entry:` module — the manifest *is* the workflow, so `loadWorkflowHandle`
+ * returns it directly with nothing to reconcile against.
+ */
+import type { WorkflowHandle } from "@agentproto/workflow";
+import type { WorkspaceHandle } from "@agentproto/workspace";
+import type { AgentEntry, EmittedApp } from "./types.js";
+interface EmitInput {
+    readonly agents: readonly AgentEntry[];
+    readonly workflows: readonly WorkflowHandle[];
+    readonly workspace?: WorkspaceHandle;
+}
+export declare function emitApp(app: EmitInput, dir: string): Promise<EmittedApp>;
+export {};
+//# sourceMappingURL=emit.d.ts.map

package/dist/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAGxD,UAAU,SAAS;IACjB,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAA;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAA;CACrC;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAkC9E"}

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @agentproto/app-kit — declare one or more agents (with their system
+ * prompts) and the workflows they run in one TypeScript module, then
+ * import them anywhere.
+ *
+ * A thin umbrella over AIP-42 `defineAgent` + AIP-15 `defineWorkflow`:
+ *
+ *   - `defineApp({ agents, workflows, attach })` cross-links agents and
+ *     workflows (every workflow an agent lists must be bundled, and every
+ *     bundled workflow must be listed by some agent), and carries any
+ *     other AIP handles you `attach` (AIP-6 company, AIP-25 persona,
+ *     AIP-47 role…). Returns a frozen `AppHandle`.
+ *   - `handle.toMastraAgents(resolvers)` builds each agent into a Mastra
+ *     agent whose `instructions` field is the real system prompt — the
+ *     AGENT.md body (via `@agentproto/mastra`).
+ *   - `handle.emit(dir)` writes `.agentproto/agents/<id>/AGENT.md` + shared
+ *     `.agentproto/workflows/<id>/WORKFLOW.md` manifests under an
+ *     agentproto-owned base (not the shared root `.agents/`), plus a root
+ *     `WORKSPACE.md` when the app has a `workspace`.
+ *
+ * An app may declare a home `workspace` (AIP-34 `defineWorkspace`, or a
+ * `{ id, name, owner, storage? }` shorthand). Its `owner` is the tenant
+ * (guild / user / org) and its `storage` the backing store (defaults to
+ * local-fs) — the tenant/local-storage model AIP-34/35 already ship, so
+ * app-kit reuses it rather than inventing tenant folders.
+ *
+ * There is no `systemPrompt` field in AIP: the prompt is the AGENT.md
+ * BODY (frontmatter is `.strict()`). So each agent carries an optional
+ * `body`; omit it and the prompt composes from persona / boundaries /
+ * traits, the way Guilde assembles an operator prompt from role + persona.
+ *
+ * `@mastra/core` is a peer dependency — install it in the host if you
+ * call `toMastraAgent(s)`. `emit` has no Mastra dependency.
+ */
+export { defineApp, AppDefinitionError } from "./define-app.js";
+export { emitApp } from "./emit.js";
+export { refKey, stripOwner } from "./refs.js";
+export type { AppDefinition, AppHandle, AgentEntry, DoctypeHandle, WorkspaceShorthand, WorkspaceInput, ToMastraAgentOptions, EmittedApp, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC9C,YAAY,EACV,aAAa,EACb,SAAS,EACT,UAAU,EACV,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,oBAAoB,EACpB,UAAU,GACX,MAAM,YAAY,CAAA"}

package/dist/index.mjs

@@ -0,0 +1,182 @@
+import { buildMastraAgent } from '@agentproto/mastra';
+import { defineWorkspace } from '@agentproto/workspace';
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import matter from 'gray-matter';
+
+/**
+ * @agentproto/app-kit v0.1.0
+ * Declare an agent + its workflows in one TS module (AIP-42 + AIP-15).
+ */
+
+
+// src/refs.ts
+function refKey(ref) {
+  if (typeof ref === "string") return ref;
+  return ref.ref ?? ref.file ?? JSON.stringify(ref.inline ?? ref);
+}
+function stripOwner(id) {
+  const m = id.match(/^@[^/]+\/(.+)$/);
+  return m ? m[1] : id;
+}
+async function emitApp(app, dir) {
+  let workspacePath;
+  if (app.workspace) {
+    await mkdir(dir, { recursive: true });
+    workspacePath = join(dir, "WORKSPACE.md");
+    await writeFile(
+      workspacePath,
+      toManifest(app.workspace, app.workspace.description ?? app.workspace.name),
+      "utf8"
+    );
+  }
+  const agentPaths = {};
+  for (const { agent, body } of app.agents) {
+    const agentDir = join(dir, ".agentproto", "agents", stripOwner(agent.id));
+    await mkdir(agentDir, { recursive: true });
+    const agentPath = join(agentDir, "AGENT.md");
+    await writeFile(agentPath, toManifest(agent, body ?? ""), "utf8");
+    agentPaths[agent.id] = agentPath;
+  }
+  const workflowPaths = [];
+  for (const wf of app.workflows) {
+    const wfDir = join(dir, ".agentproto", "workflows", wf.id);
+    await mkdir(wfDir, { recursive: true });
+    const wfPath = join(wfDir, "WORKFLOW.md");
+    await writeFile(wfPath, toManifest(wf, wf.description ?? ""), "utf8");
+    workflowPaths.push(wfPath);
+  }
+  return { agentPaths, workflowPaths, ...workspacePath ? { workspacePath } : {} };
+}
+function toManifest(handle, body) {
+  const data = JSON.parse(JSON.stringify(handle));
+  return matter.stringify(`
+${body}
+`, data);
+}
+
+// src/define-app.ts
+var AppDefinitionError = class extends Error {
+  constructor(message) {
+    super(`defineApp (app-kit): ${message}`);
+    this.name = "AppDefinitionError";
+  }
+};
+function defineApp(def) {
+  if (!Array.isArray(def.agents) || def.agents.length === 0) {
+    throw new AppDefinitionError("`agents` must be a non-empty array.");
+  }
+  const agents = def.agents.map(normalizeEntry);
+  const workflows = def.workflows ?? [];
+  const attachments = def.attach ?? [];
+  const workspace = def.workspace ? toWorkspaceHandle(def.workspace) : void 0;
+  validateAttachment(agents, workflows);
+  const frozenAgents = Object.freeze(agents.map((e) => Object.freeze({ ...e })));
+  const frozenWorkflows = Object.freeze([...workflows]);
+  const frozenAttachments = Object.freeze([...attachments]);
+  const handle = {
+    agents: frozenAgents,
+    workflows: frozenWorkflows,
+    attachments: frozenAttachments,
+    ...workspace ? { workspace } : {},
+    async toMastraAgents(opts, only) {
+      const targets = only ? selectAgents(frozenAgents, only) : frozenAgents;
+      const out = {};
+      for (const entry of targets) {
+        out[entry.agent.id] = await buildOne(entry, opts);
+      }
+      return out;
+    },
+    pick(ids) {
+      return selectAgents(frozenAgents, ids);
+    },
+    async toMastraAgent(opts) {
+      if (frozenAgents.length !== 1) {
+        throw new AppDefinitionError(
+          `toMastraAgent requires exactly one agent (app has ${frozenAgents.length}); use toMastraAgents.`
+        );
+      }
+      return buildOne(frozenAgents[0], opts);
+    },
+    emit(dir) {
+      return emitApp(
+        { agents: frozenAgents, workflows: frozenWorkflows, ...workspace ? { workspace } : {} },
+        dir
+      );
+    }
+  };
+  return Object.freeze(handle);
+}
+function toWorkspaceHandle(input) {
+  if ("schema" in input) return input;
+  return defineWorkspace({
+    schema: "workspace/v1",
+    version: input.version ?? "0.1.0",
+    id: input.id,
+    name: input.name,
+    owner: input.owner,
+    storage: input.storage ?? { inline: { provider: "local-fs", config: {} } },
+    ...input.description ? { description: input.description } : {}
+  });
+}
+function selectAgents(agents, ids) {
+  const byId = new Map(agents.map((e) => [e.agent.id, e]));
+  return ids.map((id) => {
+    const entry = byId.get(id);
+    if (!entry) {
+      throw new AppDefinitionError(
+        `agent '${id}' is not in this app. Bundled: [${[...byId.keys()].join(", ")}].`
+      );
+    }
+    return entry;
+  });
+}
+function buildOne(entry, opts) {
+  return buildMastraAgent(entry.agent, { body: entry.body, ...opts });
+}
+function normalizeEntry(input) {
+  if ("agent" in input) return input;
+  return { agent: input };
+}
+function validateAttachment(agents, workflows) {
+  const seenAgentIds = /* @__PURE__ */ new Set();
+  for (const { agent } of agents) {
+    if (seenAgentIds.has(agent.id)) {
+      throw new AppDefinitionError(`duplicate agent id '${agent.id}' in the bundle.`);
+    }
+    seenAgentIds.add(agent.id);
+  }
+  const bundledIds = /* @__PURE__ */ new Set();
+  for (const wf of workflows) {
+    if (bundledIds.has(wf.id)) {
+      throw new AppDefinitionError(`duplicate workflow id '${wf.id}' in the bundle.`);
+    }
+    bundledIds.add(wf.id);
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  for (const { agent } of agents) {
+    for (const ref of workflowRefs(agent)) {
+      const key = refKey(ref);
+      referenced.add(key);
+      if (!bundledIds.has(key)) {
+        throw new AppDefinitionError(
+          `agent '${agent.id}' references workflow '${key}' but the app does not bundle it. Bundled: [${[...bundledIds].join(", ") || "none"}].`
+        );
+      }
+    }
+  }
+  for (const id of bundledIds) {
+    if (!referenced.has(id)) {
+      throw new AppDefinitionError(
+        `workflow '${id}' is bundled but no agent lists it in workflows[]. Add { ref: "${id}" } to an agent, or drop the workflow.`
+      );
+    }
+  }
+}
+function workflowRefs(agent) {
+  return agent.workflows ?? [];
+}
+
+export { AppDefinitionError, defineApp, emitApp, refKey, stripOwner };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/refs.ts","../src/emit.ts","../src/define-app.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * Ref-key extraction, shared with the same convention `buildMastraAgent`\n * uses (`packages/mastra/src/build-agent.ts` `refKey`). An AIP-27 ref is\n * a string shorthand or `{ ref | file | inline }`; the key is the string,\n * else `.ref`, else `.file`, else a stable JSON of the inline payload.\n */\n\nimport type { AnyRef } from \"@agentproto/agent\"\n\nexport function refKey(ref: AnyRef): string {\n  if (typeof ref === \"string\") return ref\n  return ref.ref ?? ref.file ?? JSON.stringify(ref.inline ?? ref)\n}\n\n/** `@agentik/writer` → `writer`; bare ids untouched. */\nexport function stripOwner(id: string): string {\n  const m = id.match(/^@[^/]+\\/(.+)$/)\n  return m ? m[1]! : id\n}\n","/**\n * `emitApp(app, dir)` — write an app's agents + workflows to disk under an\n * agentproto-owned base, so the manifests don't squat the shared root\n * `.agents/` convention:\n *\n *   <dir>/WORKSPACE.md                              (when the app has a\n *                                                    workspace — AIP-34 root\n *                                                    manifest; owner = tenant)\n *   <dir>/.agentproto/agents/<id>/AGENT.md         (one per agent)\n *   <dir>/.agentproto/workflows/<wf.id>/WORKFLOW.md (shared — a workflow may\n *                                                    be run by several agents)\n *\n * The \"tenant\" isn't a `tenants/<t>/…` path segment — it's the `owner` of\n * the AIP-34 WORKSPACE.md (guild / user / org), and local storage is its\n * AIP-35 `storage` block. So there is no bespoke tenant folder to invent.\n *\n * Both are plain markdown manifests: frontmatter = the validated handle,\n * body = the agent's `body` (its system prompt) or the workflow description.\n * Because a `defineWorkflow` handle is pure data, the WORKFLOW.md needs no\n * `entry:` module — the manifest *is* the workflow, so `loadWorkflowHandle`\n * returns it directly with nothing to reconcile against.\n */\n\nimport { mkdir, writeFile } from \"node:fs/promises\"\nimport { join } from \"node:path\"\nimport matter from \"gray-matter\"\nimport type { WorkflowHandle } from \"@agentproto/workflow\"\nimport type { WorkspaceHandle } from \"@agentproto/workspace\"\nimport type { AgentEntry, EmittedApp } from \"./types.js\"\nimport { stripOwner } from \"./refs.js\"\n\ninterface EmitInput {\n  readonly agents: readonly AgentEntry[]\n  readonly workflows: readonly WorkflowHandle[]\n  readonly workspace?: WorkspaceHandle\n}\n\nexport async function emitApp(app: EmitInput, dir: string): Promise<EmittedApp> {\n  // Root WORKSPACE.md (AIP-34): the workspace manifest whose `owner` names\n  // the tenant and whose `storage` names the backing store. The agents +\n  // workflows below live *inside* this workspace, under `.agentproto/`.\n  let workspacePath: string | undefined\n  if (app.workspace) {\n    await mkdir(dir, { recursive: true })\n    workspacePath = join(dir, \"WORKSPACE.md\")\n    await writeFile(\n      workspacePath,\n      toManifest(app.workspace, app.workspace.description ?? app.workspace.name),\n      \"utf8\",\n    )\n  }\n\n  const agentPaths: Record<string, string> = {}\n  for (const { agent, body } of app.agents) {\n    const agentDir = join(dir, \".agentproto\", \"agents\", stripOwner(agent.id))\n    await mkdir(agentDir, { recursive: true })\n    const agentPath = join(agentDir, \"AGENT.md\")\n    await writeFile(agentPath, toManifest(agent, body ?? \"\"), \"utf8\")\n    agentPaths[agent.id] = agentPath\n  }\n\n  const workflowPaths: string[] = []\n  for (const wf of app.workflows) {\n    const wfDir = join(dir, \".agentproto\", \"workflows\", wf.id)\n    await mkdir(wfDir, { recursive: true })\n    const wfPath = join(wfDir, \"WORKFLOW.md\")\n    await writeFile(wfPath, toManifest(wf, wf.description ?? \"\"), \"utf8\")\n    workflowPaths.push(wfPath)\n  }\n\n  return { agentPaths, workflowPaths, ...(workspacePath ? { workspacePath } : {}) }\n}\n\n/**\n * Serialize a handle to a `.md` manifest. gray-matter's YAML engine\n * rejects `undefined` values; a JSON clone drops them and yields a plain\n * data object (AIP handles are pure data, no functions/Dates) that\n * round-trips through the matching `parse*Manifest`. gray-matter appends\n * a trailing newline, so manifests end in exactly one newline.\n */\nfunction toManifest(handle: object, body: string): string {\n  const data: Record<string, unknown> = JSON.parse(JSON.stringify(handle))\n  return matter.stringify(`\\n${body}\\n`, data)\n}\n","/**\n * `defineApp({ agents, workflows, attach })` — bundle one or more AIP-42\n * agents, the AIP-15 workflows they run, and any other AIP artifacts into\n * one cross-linked, frozen handle.\n *\n * The only new invariant app-kit adds is *attachment*: the agents and the\n * bundled workflows must reference each other. Everything else (field\n * validation) already ran when the caller built the handles with\n * `defineAgent` / `defineWorkflow`, so `defineApp` validates the coupling,\n * not the fields.\n *\n *   - agent ids are unique within the app.\n *   - every `agent.workflows[]` ref MUST resolve to a bundled workflow id.\n *   - every bundled workflow MUST be referenced by at least one agent.\n *\n * A dangling ref (an agent points at a workflow the app didn't bundle) or\n * an orphan (a bundled workflow no agent lists) throws — that is what \"an\n * agent attached to its workflows\" means, made checkable.\n */\n\nimport { buildMastraAgent } from \"@agentproto/mastra\"\nimport { defineWorkspace } from \"@agentproto/workspace\"\nimport type { AgentHandle, AnyRef } from \"@agentproto/agent\"\nimport type { WorkflowHandle } from \"@agentproto/workflow\"\nimport type { WorkspaceHandle } from \"@agentproto/workspace\"\nimport type {\n  AgentEntry,\n  AppDefinition,\n  AppHandle,\n  DoctypeHandle,\n  ToMastraAgentOptions,\n  WorkspaceInput,\n} from \"./types.js\"\nimport { refKey } from \"./refs.js\"\nimport { emitApp } from \"./emit.js\"\n\nexport class AppDefinitionError extends Error {\n  constructor(message: string) {\n    super(`defineApp (app-kit): ${message}`)\n    this.name = \"AppDefinitionError\"\n  }\n}\n\nexport function defineApp(def: AppDefinition): AppHandle {\n  if (!Array.isArray(def.agents) || def.agents.length === 0) {\n    throw new AppDefinitionError(\"`agents` must be a non-empty array.\")\n  }\n\n  const agents = def.agents.map(normalizeEntry)\n  const workflows = def.workflows ?? []\n  const attachments = def.attach ?? []\n  const workspace = def.workspace ? toWorkspaceHandle(def.workspace) : undefined\n\n  validateAttachment(agents, workflows)\n\n  const frozenAgents = Object.freeze(agents.map((e) => Object.freeze({ ...e })))\n  const frozenWorkflows = Object.freeze([...workflows])\n  const frozenAttachments = Object.freeze([...attachments])\n\n  const handle: AppHandle = {\n    agents: frozenAgents,\n    workflows: frozenWorkflows,\n    attachments: frozenAttachments,\n    ...(workspace ? { workspace } : {}),\n\n    async toMastraAgents(opts: ToMastraAgentOptions, only?: readonly string[]) {\n      const targets = only ? selectAgents(frozenAgents, only) : frozenAgents\n      const out: Record<string, Awaited<ReturnType<typeof buildMastraAgent>>> = {}\n      for (const entry of targets) {\n        out[entry.agent.id] = await buildOne(entry, opts)\n      }\n      return out\n    },\n\n    pick(ids: readonly string[]) {\n      return selectAgents(frozenAgents, ids)\n    },\n\n    async toMastraAgent(opts: ToMastraAgentOptions) {\n      if (frozenAgents.length !== 1) {\n        throw new AppDefinitionError(\n          `toMastraAgent requires exactly one agent (app has ${frozenAgents.length}); use toMastraAgents.`,\n        )\n      }\n      return buildOne(frozenAgents[0]!, opts)\n    },\n\n    emit(dir: string) {\n      return emitApp(\n        { agents: frozenAgents, workflows: frozenWorkflows, ...(workspace ? { workspace } : {}) },\n        dir,\n      )\n    },\n  }\n\n  return Object.freeze(handle)\n}\n\n/**\n * Normalize the `workspace` input to an AIP-34 `WorkspaceHandle`. A built\n * handle (already run through `defineWorkspace`) carries `schema:\n * \"workspace/v1\"` and passes straight through; a `WorkspaceShorthand` is\n * completed with a local-fs storage default and a `0.1.0` version, then\n * validated by `defineWorkspace` — so a malformed shorthand fails with the\n * same AIP-34 diagnostic as a malformed WORKSPACE.md.\n */\nfunction toWorkspaceHandle(input: WorkspaceInput): WorkspaceHandle {\n  if (\"schema\" in input) return input\n  return defineWorkspace({\n    schema: \"workspace/v1\",\n    version: input.version ?? \"0.1.0\",\n    id: input.id,\n    name: input.name,\n    owner: input.owner,\n    storage: input.storage ?? { inline: { provider: \"local-fs\", config: {} } },\n    ...(input.description ? { description: input.description } : {}),\n  })\n}\n\n/**\n * Resolve `ids` to their app entries, preserving the caller's order. Throws\n * `AppDefinitionError` on any id the app doesn't bundle — a hand-picked list\n * that names a missing agent is a bug, not a silent no-op.\n */\nfunction selectAgents(\n  agents: readonly AgentEntry[],\n  ids: readonly string[],\n): readonly AgentEntry[] {\n  const byId = new Map(agents.map((e) => [e.agent.id, e]))\n  return ids.map((id) => {\n    const entry = byId.get(id)\n    if (!entry) {\n      throw new AppDefinitionError(\n        `agent '${id}' is not in this app. Bundled: [${[...byId.keys()].join(\", \")}].`,\n      )\n    }\n    return entry\n  })\n}\n\nfunction buildOne(entry: AgentEntry, opts: ToMastraAgentOptions) {\n  // `entry.body` (the AGENT.md body) wins as instructions; an explicit\n  // `opts.body` still overrides, matching buildMastraAgent's contract.\n  return buildMastraAgent(entry.agent, { body: entry.body, ...opts })\n}\n\nfunction normalizeEntry(input: AgentEntry | AgentHandle): AgentEntry {\n  // An AgentEntry has an `.agent`; a bare AgentHandle has `.id`/`.schema`.\n  if (\"agent\" in input) return input\n  return { agent: input }\n}\n\n/**\n * The attachment invariant across all agents: bundled workflow ids and\n * the union of every agent's `workflows[]` refs must be the same set.\n * External/registry workflow refs are out of scope for an app bundle —\n * if an agent lists it, the app must ship it.\n */\nfunction validateAttachment(\n  agents: readonly AgentEntry[],\n  workflows: readonly WorkflowHandle[],\n): void {\n  const seenAgentIds = new Set<string>()\n  for (const { agent } of agents) {\n    if (seenAgentIds.has(agent.id)) {\n      throw new AppDefinitionError(`duplicate agent id '${agent.id}' in the bundle.`)\n    }\n    seenAgentIds.add(agent.id)\n  }\n\n  const bundledIds = new Set<string>()\n  for (const wf of workflows) {\n    if (bundledIds.has(wf.id)) {\n      throw new AppDefinitionError(`duplicate workflow id '${wf.id}' in the bundle.`)\n    }\n    bundledIds.add(wf.id)\n  }\n\n  const referenced = new Set<string>()\n  for (const { agent } of agents) {\n    for (const ref of workflowRefs(agent)) {\n      const key = refKey(ref)\n      referenced.add(key)\n      if (!bundledIds.has(key)) {\n        throw new AppDefinitionError(\n          `agent '${agent.id}' references workflow '${key}' but the app does not bundle it. ` +\n            `Bundled: [${[...bundledIds].join(\", \") || \"none\"}].`,\n        )\n      }\n    }\n  }\n\n  for (const id of bundledIds) {\n    if (!referenced.has(id)) {\n      throw new AppDefinitionError(\n        `workflow '${id}' is bundled but no agent lists it in workflows[]. ` +\n          `Add { ref: \"${id}\" } to an agent, or drop the workflow.`,\n      )\n    }\n  }\n}\n\nfunction workflowRefs(agent: AgentHandle): readonly AnyRef[] {\n  return agent.workflows ?? []\n}\n\nexport type { DoctypeHandle }\n"]}

package/dist/refs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ref-key extraction, shared with the same convention `buildMastraAgent`
+ * uses (`packages/mastra/src/build-agent.ts` `refKey`). An AIP-27 ref is
+ * a string shorthand or `{ ref | file | inline }`; the key is the string,
+ * else `.ref`, else `.file`, else a stable JSON of the inline payload.
+ */
+import type { AnyRef } from "@agentproto/agent";
+export declare function refKey(ref: AnyRef): string;
+/** `@agentik/writer` → `writer`; bare ids untouched. */
+export declare function stripOwner(id: string): string;
+//# sourceMappingURL=refs.d.ts.map

package/dist/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../src/refs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAE/C,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG1C;AAED,wDAAwD;AACxD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAG7C"}

package/dist/types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Types for `@agentproto/app-kit`.
+ *
+ * An "app" is the smallest shippable unit that couples one or more AIP-42
+ * agents with the AIP-15 workflows they run — plus any other AIP artifacts
+ * you want to ride along (an AIP-6 company, AIP-25 personas, AIP-47 roles,
+ * policies…). The agents and workflows are authored with the existing
+ * `defineAgent` / `defineWorkflow`; app-kit bundles + cross-links them.
+ *
+ * On the system prompt: there is no `systemPrompt` field anywhere in AIP.
+ * The prompt is the free-text BODY of an AGENT.md (AIP-42) — frontmatter is
+ * `.strict()` and holds only metadata. So each agent carries an optional
+ * `body`; when omitted the prompt composes from the agent's persona /
+ * boundaries / traits (`composeInstructions` falls back to `description`),
+ * the same way Guilde assembles an operator's prompt from AIP-47 role
+ * instructions + AIP-25 persona rather than a stored string.
+ */
+import type { AgentHandle } from "@agentproto/agent";
+import type { WorkflowHandle } from "@agentproto/workflow";
+import type { WorkspaceHandle, WorkspaceDefinition } from "@agentproto/workspace";
+import type { BuildMastraAgentResult, BuildMastraAgentOptions } from "@agentproto/mastra";
+/**
+ * An agent paired with the prose that becomes its system prompt. `body`
+ * is the AGENT.md body (AIP-42) — the only place free-text instructions
+ * live. Optional: omit it to let the prompt compose from the agent's
+ * structured fields.
+ */
+export interface AgentEntry {
+    readonly agent: AgentHandle;
+    /** The AGENT.md body / system prompt. Optional — composed if absent. */
+    readonly body?: string;
+}
+/**
+ * Structural view of any AIP doctype handle (agent, company, persona,
+ * role, policy…). Every `defineX` handle has a stable `id`; `schema`
+ * carries the doctype literal when the doctype declares one. Kept
+ * structural so an app can `attach` any AIP artifact without app-kit
+ * depending on each doctype package.
+ */
+export interface DoctypeHandle {
+    readonly id: string;
+    readonly schema?: string;
+}
+/**
+ * Lightweight way to give an app a home workspace without hand-writing a
+ * full AIP-34 `defineWorkspace(...)`. `owner` is the tenant identity
+ * (guild / user / org — the tenant model AIP-34 already ships, not a folder
+ * segment); `storage` is the AIP-35 STORAGE block and defaults to local
+ * filesystem. `id` is the globally-addressable `@<owner-slug>/<workspace>`,
+ * whose owner segment MUST equal `owner.slug`.
+ */
+export interface WorkspaceShorthand {
+    readonly id: string;
+    readonly name: string;
+    readonly owner: WorkspaceDefinition["owner"];
+    /** AIP-35 STORAGE block. Defaults to `{ inline: { provider: "local-fs", config: {} } }`. */
+    readonly storage?: WorkspaceDefinition["storage"];
+    readonly version?: string;
+    readonly description?: string;
+}
+/**
+ * A home workspace for an app: either a full AIP-34 `WorkspaceHandle`
+ * (from `defineWorkspace`) or the `WorkspaceShorthand` above. Discriminated
+ * structurally — a built handle carries `schema: "workspace/v1"`.
+ */
+export type WorkspaceInput = WorkspaceHandle | WorkspaceShorthand;
+/**
+ * Input to `defineApp`. Each `agents[]` entry is an already-validated
+ * `AgentHandle` (bare, no body) or an `AgentEntry` (handle + body).
+ */
+export interface AppDefinition {
+    readonly agents: readonly (AgentEntry | AgentHandle)[];
+    readonly workflows?: readonly WorkflowHandle[];
+    /** Any other AIP handles to carry with the app (AIP-6/25/47/…). */
+    readonly attach?: readonly DoctypeHandle[];
+    /**
+     * Optional home workspace (AIP-34). When set, the app is content
+     * *inside* a workspace whose `owner` names the tenant and whose
+     * `storage` names the backing store — `emit` writes a root `WORKSPACE.md`
+     * alongside the agents. Omit for a workspace-less bundle.
+     */
+    readonly workspace?: WorkspaceInput;
+}
+/** Options for `toMastraAgent(s)`. Same resolvers as `buildMastraAgent`. */
+export type ToMastraAgentOptions = BuildMastraAgentOptions;
+/** Paths written by `AppHandle.emit`. */
+export interface EmittedApp {
+    /** Absolute paths to the written `AGENT.md` files, keyed by agent id. */
+    readonly agentPaths: Readonly<Record<string, string>>;
+    /** Absolute paths to the written `WORKFLOW.md` files, in input order. */
+    readonly workflowPaths: readonly string[];
+    /** Absolute path to the root `WORKSPACE.md`, when the app has a workspace. */
+    readonly workspacePath?: string;
+}
+/**
+ * The frozen result of `defineApp`. Carries the cross-linked agents +
+ * workflows + attachments and the two consumption paths.
+ */
+export interface AppHandle {
+    readonly agents: readonly AgentEntry[];
+    readonly workflows: readonly WorkflowHandle[];
+    readonly attachments: readonly DoctypeHandle[];
+    /** The app's home workspace (AIP-34), normalized to a handle. Absent if none. */
+    readonly workspace?: WorkspaceHandle;
+    /**
+     * Build agents into runnable Mastra agents whose `instructions` field is
+     * the real system prompt (body → `composeInstructions`), keyed by agent id.
+     *
+     * Pass `only` to build just those agent ids instead of the whole app — the
+     * "use n of a team" path, so a host doesn't pay to build agents it won't
+     * run. Every id in `only` must belong to the app (unknown ids throw).
+     */
+    toMastraAgents(opts: ToMastraAgentOptions, only?: readonly string[]): Promise<Record<string, BuildMastraAgentResult>>;
+    /**
+     * Select a subset of the app's agents by id, as a fresh readonly list —
+     * without building them. Throws `AppDefinitionError` on an unknown id.
+     * Handy to inspect or hand-pick before `toMastraAgents`.
+     */
+    pick(ids: readonly string[]): readonly AgentEntry[];
+    /**
+     * Single-agent convenience. Throws if the app has zero or more than
+     * one agent — use `toMastraAgents` for multi-agent apps.
+     */
+    toMastraAgent(opts: ToMastraAgentOptions): Promise<BuildMastraAgentResult>;
+    /**
+     * Write one `AGENT.md` per agent + one shared `WORKFLOW.md` per workflow
+     * under `<dir>/.agentproto/`, plus a root `<dir>/WORKSPACE.md` when the
+     * app has a `workspace`. Returns the written paths.
+     */
+    emit(dir: string): Promise<EmittedApp>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@agentproto/app-kit",
+  "version": "0.2.0",
+  "description": "@agentproto/app-kit — declare an agent (with its system prompt) and its workflows in one TypeScript module and import them anywhere. A thin umbrella over AIP-42 defineAgent + AIP-15 defineWorkflow: defineApp cross-links the two (every workflow agent-step must target the app's agent, every agent workflow ref must resolve), toMastraAgent turns the AGENT.md body into a real Mastra `instructions` field, and emit writes the .agents/<id>/AGENT.md + WORKFLOW.md(+entry) pair that runs through the agentproto-run lane unchanged.",
+  "keywords": [
+    "agentproto",
+    "aip-42",
+    "aip-15",
+    "defineApp",
+    "agent",
+    "workflow",
+    "open-standard"
+  ],
+  "homepage": "https://agentproto.sh/docs/aip-42",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/app-kit"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "@agentproto/agent": "0.2.1",
+    "@agentproto/mastra": "0.2.2",
+    "@agentproto/workflow": "0.1.0",
+    "@agentproto/workspace": "0.1.0"
+  },
+  "peerDependencies": {
+    "@mastra/core": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@mastra/core": "1.32.1",
+    "@types/node": "^25.6.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "@agentproto/tooling": "0.1.0-alpha.0",
+    "@agentproto/workflow-loader": "0.1.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup && tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}