@junejs/server 1.0.0-dev.14 → 1.0.0-dev.19

package/dist/adapter.d.ts

@@ -4,6 +4,7 @@ type AdapterCapabilities = {
   runtime: "edge" | "node" | "serverless" | "native" | "static";
   persistentConnections: boolean;
   assets: "platform" | "server" | "none";
+  durableObjects?: boolean;
 };
 type AdapterEntry = {
   imports: string[];
@@ -14,6 +15,10 @@ type ResourcePlan = {
     binding: string;
     databaseName: string;
   };
+  agent?: {
+    binding: string;
+    className: string;
+  };
 };
 type AdapterEmitContext = {
   appRoot: string;
@@ -39,6 +44,7 @@ interface JuneAdapter {
   }): 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;
@@ -53,4 +59,4 @@ declare function deno(opts?: {
 }): JuneAdapter;
 declare function staticSite(): JuneAdapter;
 //#endregion
-export { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, staticSite, vercel, workers };
+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,39 @@
+//#region src/agent-compile.d.ts
+declare const AGENT_MODULE_FILE = "_agent.gen.ts";
+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[];
+};
+declare function scanAgentDir(dir: string): AgentDirScan | null;
+type EmitOptions = {
+  tsExtensions?: boolean;
+};
+declare function emitAgentModule(scan: AgentDirScan, opts?: EmitOptions): string;
+declare function findAgentDir(root: string, dirName?: string): string | null;
+declare function generateAgentModule(dir: string, opts?: {
+  check?: boolean;
+} & EmitOptions): {
+  file: string;
+  code: string;
+  stale: boolean;
+  written: boolean;
+} | null;
+//#endregion
+export { AGENT_MODULE_FILE, AgentDirScan, EmitOptions, emitAgentModule, findAgentDir, generateAgentModule, scanAgentDir };

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

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 };

package/dist/agent-durable.d.ts

@@ -1,5 +1,6 @@
 import { Channel, ChannelFactory } from "@junejs/core/agent-config";
-import { InboundEvent, Model, Msg, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
+import { ChannelPolicy, InboundEvent, Model, Msg, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
+import { Connection } from "@junejs/core/connections";
 import { Resources } from "@junejs/core/resources";
 //#region src/agent-durable.d.ts
 type SqlStorageValue = ArrayBuffer | string | number | null;
@@ -47,10 +48,11 @@ type DoAgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
-  channelInstructions?: Record<string, string>;
+  channelInstructions?: Record<string, string | ChannelPolicy>;
   channels?: (Channel | ChannelFactory)[];
   env?: unknown;
-  resources?: Resources;
+  resources?: Resources | ((env: unknown) => Promise<Resources> | Resources);
+  connections?: Connection[];
   services?: unknown;
   onTurnError?: (failure: {
     turnId: string;
@@ -69,8 +71,15 @@ declare class AgentDurableObject {
   private readonly tools;
   private readonly channels;
   private readonly channelInstructions?;
-  private readonly resources;
+  private readonly resourcesInput;
+  private resourcesOpened;
+  private readonly connectionsInput;
+  private connectionsOpened;
+  private readonly doEnv;
   private readonly services;
+  private resolveResources;
+  private resolveConnections;
+  private ready;
   constructor(state: DurableObjectState, def: DoAgentDef);
   private resolveSession;
   turn(input: {

package/dist/agent-durable.js

@@ -1,7 +1,8 @@
 import { isolateLocal } from "./isolate-local.js";
 import { assertCoreRuntimeVersion } from "./core-version.js";
-import { DeliverUnsupportedError, channelDispatch, resolveChannel } from "@junejs/core/agent-config";
+import { DeliverUnsupportedError, actionToTool, channelDispatch, resolveChannel } from "@junejs/core/agent-config";
 import { AgentSession, ResumeAuthorizationError, withSystem } from "@junejs/core/agent-runtime";
+import { connectAll } from "@junejs/core/connections";
 import { ensureScope, runInScope } from "@junejs/db";
 //#region src/agent-durable.ts
 var DoSessionStore = class {
@@ -99,13 +100,40 @@ var AgentDurableObject = class {
 	tools;
 	channels;
 	channelInstructions;
-	resources;
+	resourcesInput;
+	resourcesOpened;
+	connectionsInput;
+	connectionsOpened;
+	doEnv;
 	services;
+	resolveResources() {
+		return this.resourcesOpened ??= Promise.resolve(typeof this.resourcesInput === "function" ? this.resourcesInput(this.doEnv) : this.resourcesInput ?? {});
+	}
+	resolveConnections() {
+		return this.connectionsOpened ??= (async () => {
+			if (!this.connectionsInput?.length) return;
+			const { actions, report } = await connectAll(this.connectionsInput);
+			for (const r of report) if (r.error) console.error(`[june] agent "${this.name}": connection "${r.name}" (${r.url}) failed: ${r.error}`);
+			const seen = new Set(this.tools.map((t) => t.spec.name));
+			for (const a of actions) {
+				const tool = actionToTool(a);
+				if (seen.has(tool.spec.name)) throw new Error(`AgentDurableObject(${this.name}): duplicate tool name "${tool.spec.name}" from a connection — rename so dispatch is unambiguous.`);
+				seen.add(tool.spec.name);
+				this.tools.push(tool);
+			}
+		})();
+	}
+	async ready() {
+		const [resources] = await Promise.all([this.resolveResources(), this.resolveConnections()]);
+		return resources;
+	}
 	constructor(state, def) {
 		assertCoreRuntimeVersion(`AgentDurableObject(${def.name ?? "agent"})`);
 		const store = new DoSessionStore(state.storage);
 		const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-		this.resources = def.resources ?? {};
+		this.resourcesInput = def.resources;
+		this.connectionsInput = def.connections;
+		this.doEnv = def.env;
 		this.services = def.services;
 		const name = def.name ?? "agent";
 		const sink = new InProcEventSink();
@@ -145,6 +173,10 @@ var AgentDurableObject = class {
 		this.tools = tools;
 		this.channels = channels;
 		this.channelInstructions = def.channelInstructions;
+		if (def.channelInstructions) {
+			const names = new Set(channels.map((c) => c.name));
+			for (const source of Object.keys(def.channelInstructions)) if (!names.has(source)) console.warn(`[june] agent "${name}": surface policy "${source}" matches no channel wired into this DO (${[...names].join(", ") || "none"}) — it will never fire.`);
+		}
 	}
 	resolveSession(key) {
 		if (key !== void 0) assertSessionKey(key);
@@ -162,17 +194,19 @@ var AgentDurableObject = class {
 	}
 	async turn(input) {
 		await ensureScope();
+		const resources = await this.ready();
 		const session = this.resolveSession(input.session);
 		return runInScope({
-			resources: this.resources,
+			resources,
 			services: this.services
 		}, () => session.turn(input));
 	}
 	async start(input) {
 		await ensureScope();
+		const resources = await this.ready();
 		const session = this.resolveSession(input.session);
 		return runInScope({
-			resources: this.resources,
+			resources,
 			services: this.services
 		}, () => session.start(input));
 	}
@@ -198,12 +232,13 @@ var AgentDurableObject = class {
 				deliverChannel = this.channels.find((c) => c.name === event.source);
 				if (!deliverChannel?.deliver) return Response.json({ error: `agent "${this.name}": no deliver()-capable channel named "${event.source}" is wired into this DO (DoAgentDef.channels) — the turn was NOT started` }, { status: 501 });
 			}
+			const resources = await this.ready();
 			let session;
 			let started;
 			try {
 				session = this.resolveSession(key);
 				started = runInScope({
-					resources: this.resources,
+					resources,
 					services: this.services
 				}, () => session.start({
 					userText,
@@ -227,7 +262,7 @@ var AgentDurableObject = class {
 						recipientTeamId: event.teamId
 					};
 					Promise.resolve().then(() => runInScope({
-						resources: this.resources,
+						resources,
 						services: this.services
 					}, () => deliverChannel.deliver(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
 						it.return?.();
@@ -250,11 +285,12 @@ var AgentDurableObject = class {
 				resumeChannel = this.channels.find((c) => c.name === source);
 				if (!resumeChannel?.deliverResume) return Response.json({ error: `agent "${this.name}": no deliverResume()-capable channel named "${source}" is wired into this DO (DoAgentDef.channels) — the answer was NOT applied` }, { status: 501 });
 			}
+			const resources = await this.ready();
 			let session;
 			try {
 				session = this.resolveSession(key);
 				runInScope({
-					resources: this.resources,
+					resources,
 					services: this.services
 				}, () => session.resume(turnId, inputId, input, { by }));
 			} catch (err) {
@@ -267,7 +303,7 @@ var AgentDurableObject = class {
 					const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
 					const events = { [Symbol.asyncIterator]: () => it };
 					Promise.resolve().then(() => runInScope({
-						resources: this.resources,
+						resources,
 						services: this.services
 					}, () => resumeChannel.deliverResume(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
 						it.return?.();