@junejs/server 0.1.2 → 0.2.0

package/assets/icon-latin.LICENSE.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/adapter-DcZ-W1-7.d.ts

@@ -0,0 +1,62 @@
+import { JuneConfig } from "@junejs/core/config";
+//#region src/adapter.d.ts
+type AdapterCapabilities = {
+  runtime: "edge" | "node" | "serverless" | "native" | "static";
+  persistentConnections: boolean;
+  assets: "platform" | "server" | "none";
+  durableObjects?: boolean;
+};
+type AdapterEntry = {
+  imports: string[];
+  wrap(pipelineVar: string): string;
+};
+type ResourcePlan = {
+  db?: {
+    binding: string;
+    databaseName: string;
+  };
+  agent?: {
+    binding: string;
+    className: string;
+  };
+};
+type AdapterEmitContext = {
+  appRoot: string;
+  outDir: string;
+  hasAssets: boolean;
+  linkHeader: string | null;
+  config: JuneConfig;
+  plan: ResourcePlan;
+  defaultName: string;
+  publicFiles?: string[];
+};
+interface JuneAdapter {
+  readonly name: string;
+  readonly capabilities: AdapterCapabilities;
+  readonly conditions: string[];
+  readonly buildExternal?: string[];
+  validate?(ctx: {
+    plan: ResourcePlan;
+    config: JuneConfig;
+  }): void;
+  entry(opts: {
+    linkHeader: string | null;
+  }): AdapterEntry;
+  emit(ctx: AdapterEmitContext): Promise<void>;
+}
+declare function hasDurableBinding(text: string, file: string, binding: string, className: string): boolean;
+declare function workers(opts?: {
+  name?: string;
+  domain?: string;
+}): JuneAdapter;
+declare function vercel(opts?: {
+  runtime?: "node" | "edge";
+  regions?: string[];
+}): JuneAdapter;
+declare function deno(opts?: {
+  org?: string;
+  app?: string;
+}): JuneAdapter;
+declare function staticSite(): JuneAdapter;
+//#endregion
+export { ResourcePlan as a, staticSite as c, JuneAdapter as i, vercel as l, AdapterEmitContext as n, deno as o, AdapterEntry as r, hasDurableBinding as s, AdapterCapabilities as t, workers as u };

package/dist/adapter.d.ts

@@ -1,56 +1,2 @@
-import { JuneConfig } from "@junejs/core/config";
-//#region src/adapter.d.ts
-type AdapterCapabilities = {
-  runtime: "edge" | "node" | "serverless" | "native" | "static";
-  persistentConnections: boolean;
-  assets: "platform" | "server" | "none";
-};
-type AdapterEntry = {
-  imports: string[];
-  wrap(pipelineVar: string): string;
-};
-type ResourcePlan = {
-  db?: {
-    binding: string;
-    databaseName: string;
-  };
-};
-type AdapterEmitContext = {
-  appRoot: string;
-  outDir: string;
-  hasAssets: boolean;
-  linkHeader: string | null;
-  config: JuneConfig;
-  plan: ResourcePlan;
-  defaultName: string;
-  publicFiles?: string[];
-};
-interface JuneAdapter {
-  readonly name: string;
-  readonly capabilities: AdapterCapabilities;
-  readonly conditions: string[];
-  readonly buildExternal?: string[];
-  validate?(ctx: {
-    plan: ResourcePlan;
-    config: JuneConfig;
-  }): void;
-  entry(opts: {
-    linkHeader: string | null;
-  }): AdapterEntry;
-  emit(ctx: AdapterEmitContext): Promise<void>;
-}
-declare function workers(opts?: {
-  name?: string;
-  domain?: string;
-}): JuneAdapter;
-declare function vercel(opts?: {
-  runtime?: "node" | "edge";
-  regions?: string[];
-}): JuneAdapter;
-declare function deno(opts?: {
-  org?: string;
-  app?: string;
-}): JuneAdapter;
-declare function staticSite(): JuneAdapter;
-//#endregion
-export { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, staticSite, vercel, workers };
+import { a as ResourcePlan, c as staticSite, i as JuneAdapter, l as vercel, n as AdapterEmitContext, o as deno, r as AdapterEntry, s as hasDurableBinding, t as AdapterCapabilities, u as workers } from "./adapter-DcZ-W1-7.js";
+export { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, hasDurableBinding, staticSite, vercel, workers };

package/dist/adapter.js

@@ -1,14 +1,51 @@
+import { stripJsonc } from "./tsconfig-jsx.js";
 import { existsSync } from "node:fs";
-import { copyFile, cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { copyFile, cp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
 //#region src/adapter.ts
+function hasDurableBinding(text, file, binding, className) {
+	if (file.endsWith(".toml")) {
+		const lines = text.split("\n").map((line) => {
+			let inString = false;
+			for (let i = 0; i < line.length; i++) {
+				const ch = line[i];
+				if (ch === "\"" && line[i - 1] !== "\\") inString = !inString;
+				else if (ch === "#" && !inString) return line.slice(0, i);
+			}
+			return line;
+		});
+		let inBindings = false;
+		let name;
+		let cls;
+		const matches = () => name === binding && cls === className;
+		for (const line of lines) {
+			const t = line.trim();
+			if (t.startsWith("[")) {
+				if (inBindings && matches()) return true;
+				inBindings = /^\[\[\s*durable_objects\.bindings\s*\]\]$/.test(t);
+				name = cls = void 0;
+				continue;
+			}
+			if (!inBindings) continue;
+			const kv = t.match(/^(name|class_name)\s*=\s*"([^"]*)"/);
+			if (kv) kv[1] === "name" ? name = kv[2] : cls = kv[2];
+		}
+		return inBindings && matches();
+	}
+	try {
+		return (JSON.parse(stripJsonc(text)).durable_objects?.bindings ?? []).some((b) => b.name === binding && b.class_name === className);
+	} catch {
+		return text.includes(className);
+	}
+}
 function workers(opts) {
 	return {
 		name: "workers",
 		capabilities: {
 			runtime: "edge",
 			persistentConnections: true,
-			assets: "platform"
+			assets: "platform",
+			durableObjects: true
 		},
 		conditions: [
 			"source",
@@ -25,7 +62,17 @@ function workers(opts) {
 			};
 		},
 		async emit({ appRoot, outDir, hasAssets, config, plan, defaultName }) {
-			if (existsSync(join(appRoot, "wrangler.toml")) || existsSync(join(appRoot, "wrangler.jsonc"))) return;
+			const own = ["wrangler.toml", "wrangler.jsonc"].map((f) => join(appRoot, f)).find(existsSync);
+			if (own) {
+				if (plan.agent) {
+					const cls = plan.agent.className;
+					if (!hasDurableBinding(await readFile(own, "utf8"), own, plan.agent.binding, cls)) {
+						const snippet = own.endsWith(".toml") ? `[[durable_objects.bindings]]\nname = "${plan.agent.binding}"\nclass_name = "${cls}"\n\n[[migrations]]\ntag = "v1"\nnew_sqlite_classes = ["${cls}"]` : `"durable_objects": { "bindings": [{ "name": "${plan.agent.binding}", "class_name": "${cls}" }] },\n"migrations": [{ "tag": "v1", "new_sqlite_classes": ["${cls}"] }]`;
+						console.warn(`[june build] durable agent built, but ${basename(own)} doesn't bind it — add:\n${snippet}`);
+					}
+				}
+				return;
+			}
 			const deployCfg = config.deploy;
 			await writeFile(join(outDir, "wrangler.jsonc"), JSON.stringify({
 				name: opts?.name ?? deployCfg?.name ?? defaultName,
@@ -42,6 +89,16 @@ function workers(opts) {
 					database_name: plan.db.databaseName,
 					database_id: ""
 				}] } : {},
+				...plan.agent ? {
+					durable_objects: { bindings: [{
+						name: plan.agent.binding,
+						class_name: plan.agent.className
+					}] },
+					migrations: [{
+						tag: "v1",
+						new_sqlite_classes: [plan.agent.className]
+					}]
+				} : {},
 				...opts?.domain ?? deployCfg?.domain ? { routes: [{
 					pattern: opts?.domain ?? deployCfg?.domain,
 					custom_domain: true
@@ -208,4 +265,4 @@ function staticSite() {
 	};
 }
 //#endregion
-export { deno, staticSite, vercel, workers };
+export { deno, hasDurableBinding, staticSite, vercel, workers };

package/dist/agent-compile.d.ts

@@ -0,0 +1,38 @@
+//#region src/agent-compile.d.ts
+export declare const AGENT_MODULE_FILE = "_agent.gen.ts";
+export type AgentDirScan = {
+  dir: string;
+  name: string;
+  hasConfig: boolean;
+  instructions: string | null;
+  surfaceVariants: {
+    source: string;
+    raw: string;
+  }[];
+  tools: string[];
+  skills: {
+    name: string;
+    raw: string;
+  }[];
+  channels: string[];
+  channelOverlays: {
+    source: string;
+    raw: string;
+  }[];
+  connections: string[];
+};
+export declare function scanAgentDir(dir: string): AgentDirScan | null;
+export type EmitOptions = {
+  tsExtensions?: boolean;
+};
+export declare function emitAgentModule(scan: AgentDirScan, opts?: EmitOptions): string;
+export declare function findAgentDir(root: string, dirName?: string): string | null;
+export declare function generateAgentModule(dir: string, opts?: {
+  check?: boolean;
+} & EmitOptions): {
+  file: string;
+  code: string;
+  stale: boolean;
+  written: boolean;
+} | null;
+//#endregion

package/dist/agent-compile.js

@@ -0,0 +1,145 @@
+import { stripJsonc } from "./tsconfig-jsx.js";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+//#region src/agent-compile.ts
+const AGENT_MODULE_FILE = "_agent.gen.ts";
+function list(dir, ext) {
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(ext) && !e.name.startsWith("_")).map((e) => e.name).sort();
+}
+function scanAgentDir(dir) {
+	if (!existsSync(dir)) return null;
+	const instructionsFile = join(dir, "instructions.md");
+	const scan = {
+		dir,
+		name: basename(dir),
+		hasConfig: existsSync(join(dir, "agent.ts")),
+		instructions: existsSync(instructionsFile) ? readFileSync(instructionsFile, "utf8") : null,
+		surfaceVariants: readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name.match(/^instructions\.([a-z0-9_-]+)\.md$/)).filter((m) => m !== null).sort((a, b) => a[1].localeCompare(b[1])).map((m) => ({
+			source: m[1],
+			raw: readFileSync(join(dir, m[0]), "utf8")
+		})),
+		tools: list(join(dir, "tools"), ".ts").map((f) => `./tools/${f}`),
+		skills: list(join(dir, "skills"), ".md").map((f) => ({
+			name: basename(f, ".md"),
+			raw: readFileSync(join(dir, "skills", f), "utf8")
+		})),
+		channels: list(join(dir, "channels"), ".ts").map((f) => `./channels/${f}`),
+		channelOverlays: list(join(dir, "channels"), ".md").map((f) => ({
+			source: basename(f, ".md"),
+			raw: readFileSync(join(dir, "channels", f), "utf8")
+		})),
+		connections: list(join(dir, "connections"), ".ts").map((f) => `./connections/${f}`)
+	};
+	return !scan.hasConfig && scan.instructions === null && !scan.tools.length && !scan.skills.length && !scan.channels.length && !scan.surfaceVariants.length && !scan.channelOverlays.length && !scan.connections.length ? null : scan;
+}
+function identFor(prefix, spec, taken) {
+	const stem = basename(spec).replace(/\.ts$/, "").replace(/[^A-Za-z0-9]/g, "_");
+	let id = `${prefix}_${stem}`;
+	for (let i = 2; taken.has(id); i++) id = `${prefix}_${stem}_${i}`;
+	taken.add(id);
+	return id;
+}
+function emitAgentModule(scan, opts) {
+	const spec = (s) => JSON.stringify(opts?.tsExtensions ? s : s.replace(/\.ts$/, ""));
+	const taken = /* @__PURE__ */ new Set();
+	const imports = [];
+	const toolIds = scan.tools.map((s) => {
+		const id = identFor("tool", s, taken);
+		imports.push(`import ${id} from ${spec(s)};`);
+		return id;
+	});
+	const channelIds = scan.channels.map((s) => {
+		const id = identFor("channel", s, taken);
+		imports.push(`import ${id} from ${spec(s)};`);
+		return {
+			key: basename(s, ".ts"),
+			id
+		};
+	});
+	const connectionIds = scan.connections.map((s) => {
+		const id = identFor("connection", s, taken);
+		imports.push(`import ${id} from ${spec(s)};`);
+		return id;
+	});
+	if (scan.hasConfig) imports.push(`import config from ${spec("./agent.ts")};`);
+	const lines = [
+		"// AUTO-GENERATED by June — do not edit. Compiled from this agent/ directory so",
+		"// the definition mounts without filesystem discovery (workerd has no fs).",
+		"// Regenerate with `june gen` after adding, removing, or editing agent files.",
+		...imports,
+		scan.skills.length ? `import { parseSkill, type AgentModule } from "@junejs/core/agent-config";` : `import type { AgentModule } from "@junejs/core/agent-config";`,
+		""
+	];
+	if (!scan.hasConfig) lines.push(`const config = { name: ${JSON.stringify(scan.name)} };`, "");
+	lines.push("export const agentModule: AgentModule = {", "  config,", `  instructions: ${JSON.stringify(scan.instructions ?? "")},`, scan.surfaceVariants.length ? `  surfaceInstructions: {\n${scan.surfaceVariants.map((v) => `    ${JSON.stringify(v.source)}: ${JSON.stringify(v.raw)},`).join("\n")}\n  },` : "  surfaceInstructions: {},", `  tools: [${toolIds.join(", ")}],`, scan.skills.length ? `  skills: [\n${scan.skills.map((s) => `    parseSkill(${JSON.stringify(s.name)}, ${JSON.stringify(s.raw)}),`).join("\n")}\n  ],` : "  skills: [],", channelIds.length ? `  channels: { ${channelIds.map((c) => `${JSON.stringify(c.key)}: ${c.id}`).join(", ")} },` : "  channels: {},", scan.channelOverlays.length ? `  channelInstructions: {\n${scan.channelOverlays.map((o) => `    ${JSON.stringify(o.source)}: ${JSON.stringify(o.raw)},`).join("\n")}\n  },` : "  channelInstructions: {},", `  connections: [${connectionIds.join(", ")}],`, "};", "export default agentModule;", "");
+	return lines.join("\n");
+}
+function findAgentDir(root, dirName = "agent") {
+	for (const candidate of [join(root, "app", dirName), join(root, dirName)]) if (existsSync(candidate)) return candidate;
+	return null;
+}
+function readTsconfig(path) {
+	try {
+		return JSON.parse(stripJsonc(readFileSync(path, "utf8")));
+	} catch {
+		return;
+	}
+}
+function resolveExtends(fromDir, spec) {
+	const withJson = (p) => existsSync(p) ? p : !p.endsWith(".json") && existsSync(`${p}.json`) ? `${p}.json` : void 0;
+	if (spec.startsWith(".")) return withJson(resolve(fromDir, spec));
+	for (let d = fromDir;;) {
+		const candidate = withJson(join(d, "node_modules", spec));
+		if (candidate) return candidate;
+		const parent = dirname(d);
+		if (parent === d) return void 0;
+		d = parent;
+	}
+}
+function resolveAllowTsExtensions(path, depth) {
+	if (depth > 8) return void 0;
+	const tc = readTsconfig(path);
+	if (!tc) return void 0;
+	const own = tc.compilerOptions?.allowImportingTsExtensions;
+	if (own !== void 0) return own;
+	const bases = typeof tc.extends === "string" ? [tc.extends] : [...tc.extends ?? []].reverse();
+	for (const spec of bases) {
+		const base = resolveExtends(dirname(path), spec);
+		const inherited = base ? resolveAllowTsExtensions(base, depth + 1) : void 0;
+		if (inherited !== void 0) return inherited;
+	}
+}
+function sniffTsExtensions(dir) {
+	for (let d = dir;;) {
+		const candidate = join(d, "tsconfig.json");
+		if (existsSync(candidate)) return resolveAllowTsExtensions(candidate, 0) ?? false;
+		const parent = dirname(d);
+		if (parent === d) return false;
+		d = parent;
+	}
+}
+function generateAgentModule(dir, opts) {
+	const scan = scanAgentDir(dir);
+	if (!scan) return null;
+	for (const o of scan.channelOverlays) console.warn(`[june] deprecated: channels/${o.source}.md — move it to instructions.${o.source}.md at the agent root (per-surface behavior is agent-level; see junebuild/june#149).`);
+	for (const e of readdirSync(dir, { withFileTypes: true })) if (e.isFile() && /^instructions\..+\.md$/.test(e.name) && !/^instructions\.[a-z0-9_-]+\.md$/.test(e.name)) console.warn(`[june] ${e.name}: unrecognized instructions variant — only single-segment sources (instructions.<source>.md) are parsed today; locale variants are a planned follow-up (junebuild/june#149). This file is ignored.`);
+	const code = emitAgentModule(scan, { tsExtensions: opts?.tsExtensions ?? sniffTsExtensions(dir) });
+	const file = join(dir, AGENT_MODULE_FILE);
+	const stale = (existsSync(file) ? readFileSync(file, "utf8") : null) !== code;
+	if (opts?.check) return {
+		file,
+		code,
+		stale,
+		written: false
+	};
+	if (stale) writeFileSync(file, code);
+	return {
+		file,
+		code,
+		stale,
+		written: stale
+	};
+}
+//#endregion
+export { AGENT_MODULE_FILE, emitAgentModule, findAgentDir, generateAgentModule, scanAgentDir };

package/dist/agent-discover.d.ts

@@ -1,5 +1,5 @@
-import { AgentDefinition } from "@junejs/core/agent-config";
+import { AgentDefinition, AgentModule } from "@junejs/core/agent-config";
 //#region src/agent-discover.d.ts
-declare function discoverAgent(dir: string): Promise<AgentDefinition>;
-//#endregion
-export { discoverAgent };
+export declare function discoverAgentModule(dir: string): Promise<AgentModule>;
+export declare function discoverAgent(dir: string): Promise<AgentDefinition>;
+//#endregion

package/dist/agent-discover.js

@@ -2,42 +2,24 @@ import { existsSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { basename, extname, join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { defineAgent, resolveChannel } from "@junejs/core/agent-config";
-import { connectAll } from "@junejs/core/connections";
+import { assembleAgent, parseSkill } from "@junejs/core/agent-config";
 //#region src/agent-discover.ts
 async function scan(dir, ext) {
 	if (!existsSync(dir)) return [];
-	return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isFile() && extname(e.name) === ext).map((e) => join(dir, e.name)).sort();
+	return (await readdir(dir, { withFileTypes: true })).filter((e) => e.isFile() && extname(e.name) === ext && !e.name.startsWith("_")).map((e) => join(dir, e.name)).sort();
 }
-function parseSkill(name, text) {
-	if (text.startsWith("---")) {
-		const end = text.indexOf("\n---", 3);
-		if (end !== -1) {
-			const front = text.slice(3, end);
-			const body = text.slice(end + 4).replace(/^\s*\n/, "");
-			const meta = {};
-			for (const line of front.split("\n")) {
-				const m = line.match(/^\s*(\w+)\s*:\s*(.+?)\s*$/);
-				if (m) meta[m[1]] = m[2];
-			}
-			return {
-				name: meta.name ?? name,
-				description: meta.description ?? "",
-				body
-			};
-		}
-	}
-	return {
-		name,
-		description: (text.split("\n").find((l) => l.trim()) ?? "").replace(/^#\s*/, ""),
-		body: text
-	};
-}
-async function discoverAgent(dir) {
+async function discoverAgentModule(dir) {
 	const configFile = join(dir, "agent.ts");
 	const config = existsSync(configFile) ? (await import(pathToFileURL(configFile).href)).default : { name: basename(dir) };
 	const instructionsFile = join(dir, "instructions.md");
-	const instructions = existsSync(instructionsFile) ? await readFile(instructionsFile, "utf8") : config.instructions ?? "";
+	const instructions = existsSync(instructionsFile) ? await readFile(instructionsFile, "utf8") : "";
+	const surfaceInstructions = {};
+	if (existsSync(dir)) for (const e of await readdir(dir, { withFileTypes: true })) {
+		if (!e.isFile() || !/^instructions\..+\.md$/.test(e.name)) continue;
+		const m = e.name.match(/^instructions\.([a-z0-9_-]+)\.md$/);
+		if (m) surfaceInstructions[m[1]] = await readFile(join(dir, e.name), "utf8");
+		else console.warn(`[june] ${e.name}: unrecognized instructions variant — only single-segment sources (instructions.<source>.md) are parsed today; locale variants are a planned follow-up (junebuild/june#149). This file is ignored.`);
+	}
 	const tools = [];
 	for (const f of await scan(join(dir, "tools"), ".ts")) {
 		const mod = await import(pathToFileURL(f).href);
@@ -45,31 +27,35 @@ async function discoverAgent(dir) {
 	}
 	const skills = [];
 	for (const f of await scan(join(dir, "skills"), ".md")) skills.push(parseSkill(basename(f, ".md"), await readFile(f, "utf8")));
-	const channels = [];
+	const channels = {};
 	for (const f of await scan(join(dir, "channels"), ".ts")) {
 		const mod = await import(pathToFileURL(f).href);
-		if (mod.default) channels.push(resolveChannel(mod.default, process.env));
+		if (mod.default) channels[basename(f, ".ts")] = mod.default;
 	}
-	const connectionDefs = [];
+	const channelInstructions = {};
+	for (const f of await scan(join(dir, "channels"), ".md")) {
+		const source = basename(f, ".md");
+		console.warn(`[june] deprecated: channels/${source}.md — move it to instructions.${source}.md at the agent root (per-surface behavior is agent-level; see junebuild/june#149).`);
+		channelInstructions[source] = await readFile(f, "utf8");
+	}
+	const connections = [];
 	for (const f of await scan(join(dir, "connections"), ".ts")) {
 		const mod = await import(pathToFileURL(f).href);
-		if (mod.default) connectionDefs.push(mod.default);
+		if (mod.default) connections.push(mod.default);
 	}
-	const { actions: connectionActions, report: connections } = connectionDefs.length ? await connectAll(connectionDefs) : {
-		actions: [],
-		report: []
-	};
-	tools.push(...connectionActions);
-	return defineAgent({
-		name: config.name,
-		model: config.model,
-		description: config.description,
+	return {
+		config,
 		instructions,
+		surfaceInstructions,
 		tools,
 		skills,
 		channels,
+		channelInstructions,
 		connections
-	});
+	};
+}
+async function discoverAgent(dir) {
+	return assembleAgent(await discoverAgentModule(dir), process.env);
 }
 //#endregion
-export { discoverAgent };
+export { discoverAgent, discoverAgentModule };