@yansirplus/cli 0.5.17 → 0.5.19

package/dist/build/agent-authoring/static-target.js

@@ -1,6 +1,6 @@
 import { WORKSPACE_TOOL_EXPOSURE_PROFILES } from "@yansirplus/runtime";
-import { digestText, isWorkspaceToolName } from "./shared.js";
-import { AGENTOS_CONFIG_CLIENT, AGENTOS_CONFIG_LLM_ROUTE, AGENTOS_CONFIG_PROFILE, AGENTOS_CONFIG_TARGET, llmMaterialEnvBindings, } from "./config.js";
+import { digestText, GENERATED_LOAD_SKILL_TOOL_NAME, GENERATED_READ_SKILL_FILE_TOOL_NAME, isWorkspaceToolName, } from "./shared.js";
+import { AGENTOS_CONFIG_CLIENT, AGENTOS_CONFIG_LLM_ROUTE, AGENTOS_CONFIG_PROFILE, AGENTOS_CONFIG_TARGET, llmMaterialEnvBindings, llmMaterialEnvBindingsForRoutes, } from "./config.js";
 const generatedPath = (path, text) => ({
     path,
     text,
@@ -18,7 +18,91 @@ const stableJsonValue = (value) => {
 };
 const stableJson = (value) => `${JSON.stringify(stableJsonValue(value), null, 2)}\n`;
 const jsString = (value) => JSON.stringify(value);
+const identifierSuffix = (value) => value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/u, "_$&");
+const routeEntries = (routes) => Object.entries(routes).sort(([left], [right]) => left.localeCompare(right));
+const uniqueLlmMaterialEnvBindings = (routes) => {
+    const bindings = new Map();
+    for (const binding of llmMaterialEnvBindingsForRoutes(routes)) {
+        bindings.set(`${binding.kind}:${binding.ref}`, binding);
+    }
+    return [...bindings.values()].sort((left, right) => `${left.kind}:${left.ref}`.localeCompare(`${right.kind}:${right.ref}`));
+};
+const renderMaterialValueFunction = (routes) => {
+    const bindings = uniqueLlmMaterialEnvBindings(routes);
+    const cases = bindings
+        .map((binding) => `  if (ref.kind === ${jsString(binding.kind)} && ref.ref === ${jsString(binding.ref)}) {
+    return materialEnvValue(env, ${jsString(binding.envName)});
+  }`)
+        .join("\n");
+    return `const materialValue = (
+  env: AgentOSTargetEnv,
+  ref: { readonly kind: string; readonly ref: string },
+): NonNullable<unknown> | null => {
+${cases}
+  return null;
+};`;
+};
+const renderGeneratedProviderPreflight = (routes) => {
+    const diagnostics = routeEntries(routes)
+        .map(([bindingRef, route]) => `  ...preflightOpenAiCompatibleProviderMaterial({
+    route: {
+      kind: ${jsString(route.route)},
+      endpointRef: ${jsString(route.endpointRef)},
+      credentialRef: ${jsString(route.credentialRef)},
+      modelId: typeof materialValue(env, { kind: "model", ref: ${jsString(route.modelRef)} }) === "string"
+        ? materialValue(env, { kind: "model", ref: ${jsString(route.modelRef)} }) as string
+        : "",
+    },
+    refResolver: { material: (ref) => materialValue(env, ref) },
+    routeBindingRef: ${jsString(bindingRef)},
+    modelMaterial: {
+      ref: ${jsString(route.modelRef)},
+      value: materialValue(env, { kind: "model", ref: ${jsString(route.modelRef)} }),
+    },
+  }),`)
+        .join("\n");
+    return `const generatedProviderPreflightDiagnosticsFor = (
+  env: AgentOSTargetEnv,
+): ReturnType<typeof preflightOpenAiCompatibleProviderMaterial> => [
+${diagnostics}
+];`;
+};
+const renderGeneratedLlmRoutesFor = (routes) => {
+    const checks = routeEntries(routes)
+        .map(([bindingRef, route]) => {
+        const suffix = identifierSuffix(bindingRef);
+        return `  const modelId_${suffix} = requiredStringMaterial(
+    "model",
+    ${jsString(route.modelRef)},
+    materialValue(env, { kind: "model", ref: ${jsString(route.modelRef)} }),
+  );
+  if (!modelId_${suffix}.ok) return modelId_${suffix};`;
+    })
+        .join("\n");
+    const entries = routeEntries(routes)
+        .map(([bindingRef, route]) => `      ${jsString(bindingRef)}: {
+        kind: ${jsString(route.route)},
+        endpointRef: ${jsString(route.endpointRef)},
+        credentialRef: ${jsString(route.credentialRef)},
+        modelId: modelId_${identifierSuffix(bindingRef)}.value,
+      },`)
+        .join("\n");
+    return `const generatedLlmRoutesFor = (
+  env: AgentOSTargetEnv,
+): GeneratedTargetResult<NonNullable<AgentSubmitBindings["llmRoutes"]>> => {
+${checks}
+  return {
+    ok: true,
+    value: {
+${entries}
+    },
+  };
+};`;
+};
 const importToolPath = (toolName) => `../../agent/tools/${toolName}`;
+const importChannelPath = (path) => `../../${path.replace(/\.ts$/u, "")}`;
+const importSchedulePath = (path) => `../../${path.replace(/\.ts$/u, "")}`;
+const importDynamicResolverPath = (resolverPath) => `../../${resolverPath.replace(/\.ts$/u, "")}`;
 const workspaceMutationToolNames = new Set(WORKSPACE_TOOL_EXPOSURE_PROFILES.mutation);
 const workspaceShellToolNames = new Set(WORKSPACE_TOOL_EXPOSURE_PROFILES.shell);
 const SOURCE_PACKAGE_SCOPE = "@agent-os";
@@ -28,13 +112,23 @@ const DEFAULT_STATIC_TARGET_PACKAGE_SCOPE = packageScopePattern.test(INJECTED_PU
     ? INJECTED_PUBLIC_PACKAGE_SCOPE
     : SOURCE_PACKAGE_SCOPE;
 const publicPackageSpecifier = (scope, name) => `${scope}/${name}`;
+const cloudflareTargetFor = (target) => {
+    if (target.kind === AGENTOS_CONFIG_TARGET.CLOUDFLARE_DO_V1)
+        return target;
+    throw new TypeError(`cloudflare target renderer received ${target.kind}`);
+};
 const staticTargetModules = (scope) => ({
+    runtimeCapability: publicPackageSpecifier(scope, "runtime/capability"),
     cloudflareDoRuntime: publicPackageSpecifier(scope, "runtime/cloudflare"),
-    openAiCompatibleTransport: publicPackageSpecifier(scope, "runtime/llm-effect-ai"),
+    localRuntime: publicPackageSpecifier(scope, "runtime/local"),
+    openAiCompatibleTransport: publicPackageSpecifier(scope, "runtime/llm-effect-ai/openai-compatible"),
     workspaceAgentHost: publicPackageSpecifier(scope, "runtime/workspace-agent"),
     workspaceAgentClient: publicPackageSpecifier(scope, "client/workspace-agent"),
     workspaceBinding: publicPackageSpecifier(scope, "runtime/workspace-binding"),
     workspaceEnvCloudflare: publicPackageSpecifier(scope, "runtime/cloudflare"),
+    runtimeChannel: publicPackageSpecifier(scope, "runtime/channel"),
+    runtimeSchedule: publicPackageSpecifier(scope, "runtime/schedule"),
+    runtimeRunProjector: publicPackageSpecifier(scope, "runtime/run-projector"),
     clientCore: publicPackageSpecifier(scope, "client"),
     clientSvelte: publicPackageSpecifier(scope, "client/svelte"),
     runtimeProtocol: publicPackageSpecifier(scope, "core/runtime-protocol"),
@@ -53,7 +147,659 @@ const generatedToolImports = (toolNames) => toolNames.map((toolName, index) => (
     source: importToolPath(toolName),
     imports: [`default as tool_${index}`],
 }));
+const sortedSkills = (skills) => [...skills].sort((left, right) => left.name.localeCompare(right.name));
+const sortedChannels = (channels) => [...channels].sort((left, right) => left.name.localeCompare(right.name));
+const sortedSchedules = (schedules) => [...schedules].sort((left, right) => left.scheduleId.localeCompare(right.scheduleId));
+const generatedChannelImports = (channels) => sortedChannels(channels).map((channel, index) => ({
+    kind: "authored-channel",
+    source: importChannelPath(channel.path),
+    imports: [`default as channel_${index}`],
+}));
+const generatedScheduleImports = (schedules) => sortedSchedules(schedules).map((schedule, index) => ({
+    kind: "authored-schedule",
+    source: importSchedulePath(schedule.path),
+    imports: [`default as schedule_${index}`],
+}));
+const sortedDynamicResolvers = (resolvers) => [...resolvers].sort((left, right) => left.slot.localeCompare(right.slot) || left.resolverId.localeCompare(right.resolverId));
+const generatedDynamicResolverImports = (resolvers) => sortedDynamicResolvers(resolvers).map((resolver, index) => ({
+    kind: "authored-dynamic-resolver",
+    source: importDynamicResolverPath(resolver.path),
+    imports: [`default as dynamicResolver_${index}`],
+}));
+const renderChannelRegistry = (channels, modules) => {
+    const ordered = sortedChannels(channels);
+    const channelImports = ordered
+        .map((channel, index) => `import channel_${index} from ${jsString(importChannelPath(channel.path))};`)
+        .join("\n");
+    const entries = ordered.length === 0
+        ? "[]"
+        : `[\n${ordered
+            .map((channel, index) => `  { name: ${jsString(channel.name)}, path: ${jsString(channel.path)}, channel: channel_${index} as DefinedChannel },`)
+            .join("\n")}\n]`;
+    return `${channelImports}
+${renderNamedImport(["createChannelContext"], modules.runtimeChannel)}
+${renderTypeImport(["ChannelMethod", "ChannelRequest", "ChannelRoute", "ChannelRuntime", "DefinedChannel"], modules.runtimeChannel)}
+
+type GeneratedChannelDefinition = {
+  readonly name: string;
+  readonly path: string;
+  readonly channel: DefinedChannel;
+};
+
+type GeneratedChannelRoute = ChannelRoute & {
+  readonly channelName: string;
+  readonly mountPath: string;
+  readonly channel: DefinedChannel;
+};
+
+export const generatedChannels = ${entries} as const satisfies ReadonlyArray<GeneratedChannelDefinition>;
+
+const mountedChannelPath = (channelName: string, routePath: string): string =>
+  routePath === "/" ? \`/channels/\${channelName}\` : \`/channels/\${channelName}\${routePath}\`;
+
+const generatedRoutes = generatedChannels.flatMap((entry): ReadonlyArray<GeneratedChannelRoute> =>
+  entry.channel.routes.map((route) => ({
+    ...route,
+    channelName: entry.name,
+    mountPath: mountedChannelPath(entry.name, route.path),
+    channel: entry.channel,
+  })),
+);
+
+const routeSegments = (path: string): ReadonlyArray<string> =>
+  path
+    .split("/")
+    .map((segment) => segment.trim())
+    .filter((segment) => segment.length > 0);
+
+const isRouteParamSegment = (segment: string): boolean => segment.startsWith(":");
+
+const routePatternsConflict = (left: string, right: string): boolean => {
+  const leftSegments = routeSegments(left);
+  const rightSegments = routeSegments(right);
+  if (leftSegments.length !== rightSegments.length) return false;
+  return leftSegments.every((leftSegment, index) => {
+    const rightSegment = rightSegments[index] ?? "";
+    return leftSegment === rightSegment || isRouteParamSegment(leftSegment) || isRouteParamSegment(rightSegment);
+  });
+};
+
+const assertNoGeneratedChannelRouteConflicts = (routes: ReadonlyArray<GeneratedChannelRoute>): void => {
+  for (let leftIndex = 0; leftIndex < routes.length; leftIndex += 1) {
+    const left = routes[leftIndex];
+    if (left === undefined) continue;
+    for (let rightIndex = leftIndex + 1; rightIndex < routes.length; rightIndex += 1) {
+      const right = routes[rightIndex];
+      if (right === undefined || left.method !== right.method) continue;
+      if (!routePatternsConflict(left.mountPath, right.mountPath)) continue;
+      throw new Error(
+        \`generated channel route conflict: \${left.method} \${left.mountPath} conflicts with \${right.mountPath}\`,
+      );
+    }
+  }
+};
+
+assertNoGeneratedChannelRouteConflicts(generatedRoutes);
+
+export const generatedChannelNames = generatedChannels.map((entry) => entry.name);
+export const generatedChannelRoutes = generatedRoutes;
+
+const matchGeneratedChannelPath = (
+  pattern: string,
+  pathname: string,
+): Readonly<Record<string, string>> | null => {
+  const patternSegments = routeSegments(pattern);
+  const pathSegments = routeSegments(pathname);
+  if (patternSegments.length !== pathSegments.length) return null;
+  const params: Record<string, string> = {};
+  for (let index = 0; index < patternSegments.length; index += 1) {
+    const patternSegment = patternSegments[index] ?? "";
+    const pathSegment = pathSegments[index] ?? "";
+    if (patternSegment.startsWith(":")) {
+      const paramName = patternSegment.slice(1);
+      if (paramName.length === 0) return null;
+      params[paramName] = decodeURIComponent(pathSegment);
+      continue;
+    }
+    if (patternSegment !== pathSegment) return null;
+  }
+  return params;
+};
+
+export const dispatchGeneratedChannelRequest = async (
+  request: Request,
+  runtime: ChannelRuntime,
+): Promise<Response | null> => {
+  const url = new URL(request.url);
+  const method = request.method.toUpperCase() as ChannelMethod;
+  for (const route of generatedChannelRoutes) {
+    if (route.method !== method) continue;
+    const params = matchGeneratedChannelPath(route.mountPath, url.pathname);
+    if (params === null) continue;
+    const channelRequest: ChannelRequest = {
+      method: route.method,
+      path: url.pathname,
+      params,
+      request,
+      url,
+    };
+    const principal = await route.channel.verify(channelRequest);
+    const context = createChannelContext(runtime, principal);
+    return route.handler(channelRequest, context);
+  }
+  return null;
+};
+`;
+};
+const renderScheduleRegistry = (schedules, modules) => {
+    const ordered = sortedSchedules(schedules);
+    const scheduleImports = ordered
+        .map((schedule, index) => `import schedule_${index} from ${jsString(importSchedulePath(schedule.path))};`)
+        .join("\n");
+    const entries = ordered.length === 0
+        ? "[]"
+        : `[\n${ordered
+            .map((schedule, index) => `  { scheduleId: ${jsString(schedule.scheduleId)}, path: ${jsString(schedule.path)}, cron: ${jsString(schedule.cron)}, schedule: schedule_${index} as DefinedSchedule },`)
+            .join("\n")}\n]`;
+    return `${scheduleImports}
+${renderNamedImport(["dispatchScheduleFire", "dispatchScheduleFireDelivery"], modules.runtimeSchedule)}
+${renderTypeImport([
+        "DefinedSchedule",
+        "ScheduleDefinitionProjection",
+        "ScheduleFireDeliveryDispatchInput",
+        "ScheduleFireDeliveryDispatchResult",
+        "ScheduleFireDispatchResult",
+        "SchedulePrincipal",
+        "ScheduleRuntime",
+    ], modules.runtimeSchedule)}
+${renderTypeImport(["LedgerTruthIdentity"], modules.runtimeProtocol)}
+
+type GeneratedScheduleDefinition = {
+  readonly scheduleId: string;
+  readonly path: string;
+  readonly cron: string;
+  readonly schedule: DefinedSchedule;
+};
+
+export type GeneratedScheduleTriggerInput = {
+  readonly scheduleId: string;
+  readonly scheduledAt: string | number | Date;
+  readonly appPrincipal: SchedulePrincipal;
+};
+
+export type GeneratedScheduleDispatchInput = GeneratedScheduleTriggerInput & {
+  readonly runtime: ScheduleRuntime;
+  readonly identity: LedgerTruthIdentity;
+};
+
+export type GeneratedScheduleDeliveryDispatchInput = GeneratedScheduleDispatchInput & {
+  readonly history: ScheduleFireDeliveryDispatchInput["history"];
+};
+
+export const generatedSchedules = ${entries} as const satisfies ReadonlyArray<GeneratedScheduleDefinition>;
+export const generatedScheduleDefinitions = generatedSchedules.map(
+  ({ scheduleId, path, cron }) => ({ scheduleId, path, cron }),
+) satisfies ReadonlyArray<ScheduleDefinitionProjection>;
+export const generatedScheduleIds = generatedScheduleDefinitions.map((entry) => entry.scheduleId);
+export const generatedScheduleRegistry = new Map(
+  generatedSchedules.map((entry) => [entry.scheduleId, entry]),
+);
+
+export const dispatchGeneratedSchedule = async (
+  input: GeneratedScheduleDispatchInput,
+): Promise<ScheduleFireDispatchResult> => {
+  const entry = generatedScheduleRegistry.get(input.scheduleId);
+  if (entry === undefined) {
+    throw new Error(\`unknown generated schedule: \${input.scheduleId}\`);
+  }
+  return dispatchScheduleFire({
+    runtime: input.runtime,
+    schedule: entry.schedule,
+    scheduleId: entry.scheduleId,
+    appPrincipal: input.appPrincipal,
+    scheduledAt: input.scheduledAt,
+    scopeRef: input.identity.scopeRef,
+    effectAuthorityRef: input.identity.effectAuthorityRef,
+  });
+};
+
+export const dispatchGeneratedScheduleDelivery = async (
+  input: GeneratedScheduleDeliveryDispatchInput,
+): Promise<ScheduleFireDeliveryDispatchResult> => {
+  const entry = generatedScheduleRegistry.get(input.scheduleId);
+  if (entry === undefined) {
+    throw new Error(\`unknown generated schedule: \${input.scheduleId}\`);
+  }
+  return dispatchScheduleFireDelivery({
+    history: input.history,
+    runtime: input.runtime,
+    schedule: entry.schedule,
+    scheduleId: entry.scheduleId,
+    appPrincipal: input.appPrincipal,
+    scheduledAt: input.scheduledAt,
+    scopeRef: input.identity.scopeRef,
+    effectAuthorityRef: input.identity.effectAuthorityRef,
+  });
+};
+`;
+};
+const renderSkillCatalog = (skills) => {
+    const entries = sortedSkills(skills).map((skill) => `  ${JSON.stringify(stableJsonValue({
+        description: skill.description,
+        digest: skill.digest,
+        files: skill.files.map((file) => ({
+            bytes: file.bytes,
+            digest: file.digest,
+            path: file.path,
+            text: file.text,
+        })),
+        name: skill.name,
+        path: skill.path,
+        text: skill.text,
+    }))}`);
+    return entries.length === 0 ? "[]" : `[\n${entries.join(",\n")}\n]`;
+};
+const renderInstructionFragments = (fragments) => {
+    const entries = [...fragments]
+        .sort((left, right) => left.fragmentId.localeCompare(right.fragmentId))
+        .map((fragment) => `  ${JSON.stringify(stableJsonValue({
+        digest: fragment.digest,
+        id: fragment.fragmentId,
+        text: fragment.text,
+    }))}`);
+    return entries.length === 0 ? "[]" : `[\n${entries.join(",\n")}\n]`;
+};
+const renderDynamicCapabilityCatalog = (normalized, toolNames, hasSkills) => {
+    const manifestTools = normalized.deployment.manifest.tools ?? {};
+    const dynamicToolNames = [
+        ...toolNames,
+        ...(hasSkills ? [GENERATED_LOAD_SKILL_TOOL_NAME, GENERATED_READ_SKILL_FILE_TOOL_NAME] : []),
+    ];
+    return JSON.stringify(stableJsonValue({
+        instructions: normalized.instructionFragments.map((fragment) => ({
+            digest: fragment.digest,
+            id: fragment.fragmentId,
+        })),
+        skills: normalized.skills.map((skill) => ({
+            digest: skill.digest,
+            id: skill.name,
+        })),
+        tools: [...new Set(dynamicToolNames)].sort().map((toolName) => ({
+            id: toolName,
+            ...(manifestTools[toolName]?.bindingRef === undefined
+                ? {}
+                : { bindingRef: manifestTools[toolName]?.bindingRef }),
+        })),
+    }), null, 2);
+};
+const renderDynamicResolverImportStatements = (resolvers) => sortedDynamicResolvers(resolvers)
+    .map((resolver, index) => `import dynamicResolver_${index} from ${jsString(importDynamicResolverPath(resolver.path))};`)
+    .join("\n");
+const renderDynamicCapabilitySupport = (normalized, toolNames, hasSkills) => {
+    const resolvers = sortedDynamicResolvers(normalized.dynamicResolvers);
+    const resolverEntries = resolvers.length === 0
+        ? "[]"
+        : `[\n${resolvers
+            .map((resolver, index) => `  {
+    resolverId: ${jsString(resolver.resolverId)},
+    slot: ${jsString(resolver.slot)},
+    resolve: dynamicResolver_${index},
+  },`)
+            .join("\n")}\n]`;
+    return `${renderDynamicResolverImportStatements(resolvers)}
+
+const generatedDynamicCapabilityCatalog = ${renderDynamicCapabilityCatalog(normalized, toolNames, hasSkills)} satisfies DynamicCapabilityCompiledCatalog;
+
+const generatedInstructionFragments = ${renderInstructionFragments(normalized.instructionFragments)} satisfies ReadonlyArray<SubmitInstructionFragment>;
+
+const generatedDynamicCapabilityResolvers = ${resolverEntries} satisfies ReadonlyArray<DynamicCapabilityResolverDefinition>;
+
+const generatedDynamicCapabilityTurnEvent = (
+  refs: { readonly sessionRef?: string; readonly turnRef?: string } = {},
+): DynamicCapabilityEventRef => ({
+  name: DYNAMIC_CAPABILITY_EVENT.TURN_STARTED,
+  ...(refs.sessionRef === undefined ? {} : { sessionRef: refs.sessionRef }),
+  ...(refs.turnRef === undefined ? {} : { turnRef: refs.turnRef }),
+});
+
+const generatedDynamicSubmitBindingsFor = async (
+  event: DynamicCapabilityEventRef,
+  input: DynamicCapabilityRunInput | undefined = undefined,
+): Promise<GeneratedTargetResult<Pick<AgentSubmitBindings, "dynamicCapabilityProjection" | "instructionFragments">>> => {
+  const projection = await runDynamicCapabilityResolvers({
+    event,
+    catalog: generatedDynamicCapabilityCatalog,
+    resolvers: generatedDynamicCapabilityResolvers,
+    input,
+    materials: semanticManifest.materials ?? {},
+  });
+  if (!projection.ok) {
+    return targetFailure(\`dynamic capability resolver failed: \${JSON.stringify(projection.issues)}\`);
+  }
+  return {
+    ok: true,
+    value: {
+      dynamicCapabilityProjection: projection.projection,
+      instructionFragments: generatedInstructionFragments,
+    },
+  };
+};`;
+};
+const renderSkillSupport = (skills) => {
+    if (skills.length === 0)
+        return "";
+    return `
+type GeneratedSkill = {
+  readonly name: string;
+  readonly description: string;
+  readonly path: string;
+  readonly digest: string;
+  readonly text: string;
+  readonly files: ReadonlyArray<{
+    readonly path: string;
+    readonly digest: string;
+    readonly bytes: number;
+    readonly text: string;
+  }>;
+};
+
+type GeneratedSkillFile = GeneratedSkill["files"][number];
+
+type LoadedGeneratedSkill = Omit<GeneratedSkill, "files"> & {
+  readonly files: ReadonlyArray<Omit<GeneratedSkillFile, "text">>;
+};
+
+const generatedSkillCatalog = ${renderSkillCatalog(skills)} satisfies ReadonlyArray<GeneratedSkill>;
+const generatedSkillNames = generatedSkillCatalog.map((skill) => skill.name);
+const generatedSkillByName = Object.fromEntries(
+  generatedSkillCatalog.map((skill) => [skill.name, skill]),
+) as Readonly<Record<string, GeneratedSkill>>;
+const generatedSkillFilePathCatalog = generatedSkillCatalog.flatMap((skill) =>
+  skill.files.map((file) => ({ name: skill.name, path: file.path })),
+);
+const generatedVisibleSkillCatalogFor = (
+  projection: DynamicCapabilityProjection | undefined,
+): ReadonlyArray<GeneratedSkill> => {
+  if (projection === undefined) return generatedSkillCatalog;
+  const visible = new Set(
+    projection.skills.filter((skill) => skill.visible).map((skill) => skill.id),
+  );
+  return generatedSkillCatalog.filter((skill) => visible.has(skill.name));
+};
+
+const generatedSkillsSystemAdvert = (
+  projection: DynamicCapabilityProjection | undefined,
+): string => [
+  "Available agent skills are not loaded by default.",
+  ...generatedVisibleSkillCatalogFor(projection).map((skill) => \`- \${skill.name}: \${skill.description}\`),
+  "Do not assume a skill's full instructions until ${GENERATED_LOAD_SKILL_TOOL_NAME} returns it.",
+].join("\\n");
+
+const generatedSystemPrompt = (
+  system: string | undefined,
+  projection: DynamicCapabilityProjection | undefined,
+): string =>
+  system === undefined || system.length === 0
+    ? generatedSkillsSystemAdvert(projection)
+    : \`\${system}\\n\\n\${generatedSkillsSystemAdvert(projection)}\`;
+
+const generatedLoadedSkill = (skill: GeneratedSkill): LoadedGeneratedSkill => ({
+  name: skill.name,
+  description: skill.description,
+  path: skill.path,
+  digest: skill.digest,
+  text: skill.text,
+  files: skill.files.map((file) => ({
+    path: file.path,
+    digest: file.digest,
+    bytes: file.bytes,
+  })),
+});
+
+const generatedFrameworkToolsFor = (
+  projection: DynamicCapabilityProjection | undefined,
+): Readonly<Record<string, Tool>> => {
+  const visibleSkillNames = new Set(
+    generatedVisibleSkillCatalogFor(projection).map((skill) => skill.name),
+  );
+  if (visibleSkillNames.size === 0) return {};
+  const visibleSkill = (name: string): GeneratedSkill | null => {
+    if (!visibleSkillNames.has(name)) return null;
+    return generatedSkillByName[name] ?? null;
+  };
+  const generatedLoadSkillTool = defineProductTool({
+  name: ${jsString(GENERATED_LOAD_SKILL_TOOL_NAME)},
+  description: "Load the full text of a CLI-authored agent skill by name.",
+  args: Schema.Struct({ name: Schema.String }),
+  authority: "agentos.generated.skills",
+  authorityId: "agentos.generated.skills.load_skill",
+  admit: ({ name }) => Effect.succeed({ ok: visibleSkillNames.has(name) } as const),
+  execute: ({ name }) => {
+    const skill = visibleSkill(name);
+    if (skill === null) return Effect.fail(Error(\`unknown skill \${name}\`));
+    return Effect.succeed(generatedLoadedSkill(skill));
+  },
+  });
+
+  const generatedReadSkillFileTool = defineProductTool({
+  name: ${jsString(GENERATED_READ_SKILL_FILE_TOOL_NAME)},
+  description: "Read one declared supporting file from a CLI-authored agent skill package.",
+  args: Schema.Struct({
+    name: Schema.String,
+    path: Schema.String,
+  }),
+  authority: "agentos.generated.skills",
+  authorityId: "agentos.generated.skills.read_skill_file",
+  admit: ({ name, path }) =>
+    Effect.succeed({
+      ok:
+        visibleSkillNames.has(name) &&
+        generatedSkillFilePathCatalog.some((file) => file.name === name && file.path === path),
+    } as const),
+  execute: ({ name, path }) => {
+    const skill = visibleSkill(name);
+    const file = skill?.files.find((candidate) => candidate.path === path);
+    if (skill === null || file === undefined) {
+      return Effect.fail(Error(\`unknown skill file \${name}/\${path}\`));
+    }
+    return Effect.succeed({
+      name,
+      path: file.path,
+      digest: file.digest,
+      text: file.text,
+    });
+  },
+  });
+
+  return {
+    ${jsString(GENERATED_LOAD_SKILL_TOOL_NAME)}: generatedLoadSkillTool,
+    ${jsString(GENERATED_READ_SKILL_FILE_TOOL_NAME)}: generatedReadSkillFileTool,
+  } satisfies Readonly<Record<string, Tool>>;
+};
+`;
+};
+const renderSubmitSpecFromRunInput = (hasSkills) => `const submitSpecFromRunInput = (
+  input: SubmitRunInput,
+  dynamicCapabilityProjection: DynamicCapabilityProjection | undefined,
+): AgentSubmitSpec => ({
+  input,
+  intent: input.intent,
+  context: input.context,
+  ${hasSkills ? "system: generatedSystemPrompt(input.system, dynamicCapabilityProjection)," : "...(input.system === undefined ? {} : { system: input.system }),"}
+  ...(input.budget === undefined ? {} : { budget: input.budget }),
+  ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
+  ...(input.traceContext === undefined ? {} : { traceContext: input.traceContext }),
+  ...(input.dynamicCapability === undefined ? {} : { dynamicCapability: input.dynamicCapability }),
+  ...(input.materials === undefined ? {} : { materials: input.materials }),
+  ...(input.toolContext === undefined ? {} : { toolContext: input.toolContext }),
+  ...(input.toolPolicy === undefined ? {} : { toolPolicy: input.toolPolicy }),
+  ...(input.decisionInterrupts === undefined ? {} : { decisionInterrupts: input.decisionInterrupts }),
+  ...(input.resume === undefined ? {} : { resume: input.resume }),
+});`;
+const renderProductApiHelpers = () => `export interface AgentSessionSubmitTurnInput extends SubmitRunInput {
+  readonly sessionRef: string;
+  readonly turnRef: string;
+  readonly idempotencyKey?: string;
+}
+
+export interface AgentWorkflowRunInput extends SubmitRunInput {
+  readonly workflowId: string;
+  readonly workflowRunId: string;
+  readonly idempotencyKey?: string;
+  readonly inputDigest?: string;
+}
+
+export interface AgentWorkflowRunRef {
+  readonly workflowId: string;
+  readonly workflowRunId: string;
+}
+
+const submitRunInputFields = (input: SubmitRunInput): SubmitRunInput => ({
+  intent: input.intent,
+  context: input.context,
+  ...(input.system === undefined ? {} : { system: input.system }),
+  ...(input.budget === undefined ? {} : { budget: input.budget }),
+  ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
+  ...(input.traceContext === undefined ? {} : { traceContext: input.traceContext }),
+  ...(input.dynamicCapability === undefined ? {} : { dynamicCapability: input.dynamicCapability }),
+  ...(input.materials === undefined ? {} : { materials: input.materials }),
+  ...(input.toolContext === undefined ? {} : { toolContext: input.toolContext }),
+  ...(input.toolPolicy === undefined ? {} : { toolPolicy: input.toolPolicy }),
+  ...(input.decisionInterrupts === undefined ? {} : { decisionInterrupts: input.decisionInterrupts }),
+  ...(input.resume === undefined ? {} : { resume: input.resume }),
+});
+
+const submitRunInputFromWorkflowRun = (
+  input: AgentWorkflowRunInput,
+): SubmitRunInput => submitRunInputFields(input);
+
+const submitRunInputFromSessionTurn = (
+  input: AgentSessionSubmitTurnInput,
+): SubmitRunInput => submitRunInputFields(input);`;
+const renderProductApiDurableObjectMethods = () => `
+  submitSessionTurn(input: AgentSessionSubmitTurnInput): Promise<SubmitResult> {
+    return generatedSubmitBindingsFor(
+      this.targetEnv,
+      generatedDynamicCapabilityTurnEvent({
+        sessionRef: input.sessionRef,
+        turnRef: input.turnRef,
+      }),
+      input.dynamicCapability,
+    ).then((bindings) =>
+      bindings.ok
+        ? this.submitWithBindingsAndProductLink(
+            submitSpecFromRunInput(
+              submitRunInputFromSessionTurn(input),
+              bindings.value.dynamicCapabilityProjection,
+            ),
+            bindings.value,
+            {
+              kind: "session_turn",
+              sessionRef: input.sessionRef,
+              turnRef: input.turnRef,
+              ...(input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }),
+            },
+          )
+        : rejectTargetFailure(bindings),
+    );
+  }
+
+  inspectSession(input: { readonly sessionRef: string }): Promise<AgentSessionProjection> {
+    return this.events(semanticTruthIdentity).then((events) =>
+      projectAgentSession(events, input.sessionRef),
+    );
+  }
+
+  listSessions(): Promise<AgentSessionListProjection> {
+    return this.events(semanticTruthIdentity).then((events) => projectAgentSessions(events));
+  }
+
+  runWorkflow(input: AgentWorkflowRunInput): Promise<SubmitResult> {
+    return generatedSubmitBindingsFor(
+      this.targetEnv,
+      generatedDynamicCapabilityTurnEvent(),
+      input.dynamicCapability,
+    ).then((bindings) =>
+      bindings.ok
+        ? this.submitWithBindingsAndProductLink(
+            submitSpecFromRunInput(
+              submitRunInputFromWorkflowRun(input),
+              bindings.value.dynamicCapabilityProjection,
+            ),
+            bindings.value,
+            {
+              kind: "workflow_run",
+              workflowId: input.workflowId,
+              workflowRunId: input.workflowRunId,
+              ...(input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }),
+              ...(input.inputDigest === undefined ? {} : { inputDigest: input.inputDigest }),
+            },
+          )
+        : rejectTargetFailure(bindings),
+    );
+  }
+
+  inspectWorkflowRun(input: AgentWorkflowRunRef): Promise<WorkflowRunProjection | null> {
+    return this.events(semanticTruthIdentity).then((events) =>
+      projectWorkflowRun(events, input.workflowId, input.workflowRunId),
+    );
+  }
+
+  listWorkflowRuns(input: { readonly workflowId: string }): Promise<WorkflowRunListProjection> {
+    return this.events(semanticTruthIdentity).then((events) =>
+      projectWorkflowRuns(events, input.workflowId),
+    );
+  }`;
+const renderScheduleDurableObjectHelpers = () => `
+const generatedScheduleRuntimeFor = (target: {
+  readonly submitSessionTurn: (input: AgentSessionSubmitTurnInput) => Promise<SubmitResult>;
+  readonly runWorkflow: (input: AgentWorkflowRunInput) => Promise<SubmitResult>;
+}) =>
+  Object.freeze({
+    sessions: Object.freeze({
+      submitTurn: (input: AgentSessionSubmitTurnInput) => target.submitSessionTurn(input),
+    }),
+    workflows: Object.freeze({
+      run: (input: AgentWorkflowRunInput) => target.runWorkflow(input),
+    }),
+  });`;
+const renderScheduleDurableObjectMethod = () => `
+  dispatchSchedule(input: GeneratedScheduleTriggerInput): Promise<unknown> {
+    return this.events(semanticTruthIdentity).then((history) =>
+      dispatchGeneratedScheduleDelivery({
+        ...input,
+        history,
+        identity: semanticTruthIdentity,
+        runtime: generatedScheduleRuntimeFor(this),
+      }).then((result) => this.commitScheduleFireDispatchFullWithDelivery(result)),
+    );
+  }
+`;
+const renderGeneratedWorkspaceOperations = (workspaceToolArray, usesMutationTools, usesShellTools) => `const generatedWorkspaceToolNames = ${workspaceToolArray};
+
+const generatedWorkspaceToolInteractionFor = (
+  name: (typeof generatedWorkspaceToolNames)[number],
+): "never" | "approval" => {
+  const interaction = semanticManifest.tools?.[name]?.interaction;
+  if (interaction === "never" || interaction === "approval") return interaction;
+  throw Error(\`invalid workspace tool interaction for \${name}: \${String(interaction)}\`);
+};
+
+const generatedWorkspaceToolInteractions = Object.fromEntries(
+  generatedWorkspaceToolNames.map((name) => [name, generatedWorkspaceToolInteractionFor(name)]),
+) as Readonly<Partial<Record<(typeof generatedWorkspaceToolNames)[number], "never" | "approval">>>;
+
+const generatedWorkspaceOperations = {
+  toolNames: generatedWorkspaceToolNames,
+  mutationPolicy: ${usesMutationTools ? '"receipt-backed"' : '"disabled"'},
+  shellPolicy: ${usesShellTools ? '"receipt-backed"' : '"disabled"'},
+  toolInteractions: generatedWorkspaceToolInteractions,
+} as const;`;
 const renderWorkspaceStaticTarget = (normalized, toolNames, modules) => {
+    const target = cloudflareTargetFor(normalized.target);
+    const hasSkills = normalized.skills.length > 0;
+    const hasDynamicCapability = true;
+    const hasSchedules = normalized.schedules.length > 0;
     const authoredToolNames = new Set(normalized.authoredToolNames);
     const workspaceToolList = toolNames.filter((toolName) => isWorkspaceToolName(toolName) && !authoredToolNames.has(toolName));
     const customToolNames = toolNames.filter((toolName) => authoredToolNames.has(toolName));
@@ -71,23 +817,57 @@ const renderWorkspaceStaticTarget = (normalized, toolNames, modules) => {
     const handlerRecord = `{\n${normalized.deployment.manifest.handlers
         .map((handler) => `  ${jsString(handler)}: generatedHandler,`)
         .join("\n")}\n}`;
-    const llmEnvByKind = Object.fromEntries(llmMaterialEnvBindings(normalized.llm).map((binding) => [binding.kind, binding.envName]));
-    const generatedLlmEnvFields = Object.values(llmEnvByKind)
-        .map((envName) => `  readonly ${envName}?: string;`)
+    const llmEnvBindings = uniqueLlmMaterialEnvBindings(normalized.llmRoutes);
+    const generatedLlmEnvFields = llmEnvBindings
+        .map((binding) => `  readonly ${binding.envName}?: string;`)
         .join("\n");
     const imports = [
         `import semanticDeclarations from "./manifest.json";`,
         `import deploymentProvenance from "./deployment.json";`,
-        renderNamedImport(["createAgentDurableObject", "installCloudflareWorkspaceOperationProvider"], modules.cloudflareDoRuntime),
-        renderNamedImport(["OpenAiCompatibleLlmTransportLive"], modules.openAiCompatibleTransport),
+        ...(hasSchedules
+            ? [renderNamedImport(["dispatchGeneratedScheduleDelivery"], "./schedules")]
+            : []),
+        renderNamedImport(["createAgentDurableObject"], modules.cloudflareDoRuntime),
+        renderNamedImport([
+            "WORKSPACE_OPERATION_HOST_FACT",
+            "defineHost",
+            "resolveRuntimeInstallGraph",
+            ...(hasDynamicCapability ? ["runDynamicCapabilityResolvers"] : []),
+            "workspaceOperations",
+        ], modules.runtimeCapability),
+        renderNamedImport(["OpenAiCompatibleLlmTransportLive", "preflightOpenAiCompatibleProviderMaterial"], modules.openAiCompatibleTransport),
+        renderNamedImport(["DYNAMIC_CAPABILITY_EVENT", "manifestTruthIdentity"], modules.runtimeProtocol),
+        renderNamedImport(["projectAgentSession", "projectAgentSessions", "projectWorkflowRun", "projectWorkflowRuns"], modules.runtimeRunProjector),
         renderNamedImport(["defineWorkspaceAgentMount", "WORKSPACE_AGENT_PROJECTION"], modules.workspaceAgentHost),
-        renderNamedImport(["bindWorkspaceToolsForRuntime"], modules.workspaceBinding),
         renderNamedImport(["makeCloudflareWorkspaceEnv"], modules.workspaceEnvCloudflare),
         renderNamedImport(["getSandbox"], modules.cloudflareSandbox),
-        renderNamedImport(["deterministicToolInvocation", "unsafeRunToolByName"], modules.coreTools),
-        renderNamedImport(["Effect"], modules.effect),
+        renderNamedImport([
+            "deterministicToolInvocation",
+            ...(hasSkills ? ["defineProductTool"] : []),
+            "unsafeRunToolByName",
+        ], modules.coreTools),
+        renderNamedImport(hasSkills ? ["Effect", "Schema"] : ["Effect"], modules.effect),
         renderTypeImport(["AgentManifest", "AgentSubmitBindings", "SubmitResult", "SubmitRunInput"], modules.runtimeProtocol),
+        ...(hasDynamicCapability
+            ? [
+                renderTypeImport([
+                    "DynamicCapabilityCompiledCatalog",
+                    "DynamicCapabilityEventRef",
+                    "DynamicCapabilityProjection",
+                    "DynamicCapabilityRunInput",
+                    "SubmitInstructionFragment",
+                ], modules.runtimeProtocol),
+                renderTypeImport(["DynamicCapabilityResolverDefinition"], modules.runtimeCapability),
+            ]
+            : []),
+        renderTypeImport([
+            "AgentSessionListProjection",
+            "AgentSessionProjection",
+            "WorkflowRunListProjection",
+            "WorkflowRunProjection",
+        ], modules.runtimeRunProjector),
         renderTypeImport(["AgentSubmitSpec"], modules.cloudflareDoRuntime),
+        ...(hasSchedules ? [renderTypeImport(["GeneratedScheduleTriggerInput"], "./schedules")] : []),
         renderTypeImport([
             "WorkspaceAgentDecideInputRequestCommandInput",
             "WorkspaceAgentCustomCommandInput",
@@ -109,6 +889,7 @@ export const targetDeclarations = semanticDeclarations;
 export const targetDeployment = deploymentProvenance;
 
 const semanticManifest = semanticDeclarations as AgentManifest;
+const semanticTruthIdentity = manifestTruthIdentity(semanticManifest);
 const generatedHandler = () => undefined;
 
 type AgentOSTargetEnv = {
@@ -120,33 +901,36 @@ ${generatedLlmEnvFields}
 type GeneratedTargetFailure = {
   readonly ok: false;
   readonly message: string;
+  readonly diagnostics?: ReturnType<typeof preflightOpenAiCompatibleProviderMaterial>;
 };
 
 type GeneratedTargetResult<Value> =
   | { readonly ok: true; readonly value: Value }
   | GeneratedTargetFailure;
 
-const targetFailure = (message: string): GeneratedTargetFailure => ({ ok: false, message });
+const targetFailure = (
+  message: string,
+  diagnostics?: ReturnType<typeof preflightOpenAiCompatibleProviderMaterial>,
+): GeneratedTargetFailure => ({
+  ok: false,
+  message,
+  ...(diagnostics === undefined || diagnostics.length === 0 ? {} : { diagnostics }),
+});
 
-const rejectTargetFailure = (failure: GeneratedTargetFailure): Promise<never> =>
-  Promise.reject(Error(failure.message));
+const rejectTargetFailure = (failure: GeneratedTargetFailure): Promise<never> => {
+  const error = Error(failure.message) as Error & {
+    diagnostics?: ReturnType<typeof preflightOpenAiCompatibleProviderMaterial>;
+  };
+  if (failure.diagnostics !== undefined) error.diagnostics = failure.diagnostics;
+  return Promise.reject(error);
+};
 
-const generatedWorkspaceToolNames = ${workspaceToolArray};
+${renderGeneratedWorkspaceOperations(workspaceToolArray, usesMutationTools, usesShellTools)}
 const generatedCustomTools = ${customToolRecord} satisfies Readonly<Record<string, Tool>>;
+${hasDynamicCapability ? renderDynamicCapabilitySupport(normalized, toolNames, hasSkills) : ""}
+${renderSkillSupport(normalized.skills)}
 const generatedWorkspaceSandboxId = ${jsString(normalized.workspace.cloudflareSandboxId)};
 
-const generatedWorkspaceToolInteractionFor = (
-  name: (typeof generatedWorkspaceToolNames)[number],
-): "never" | "approval" => {
-  const interaction = semanticManifest.tools?.[name]?.interaction;
-  if (interaction === "never" || interaction === "approval") return interaction;
-  throw Error(\`invalid workspace tool interaction for \${name}: \${String(interaction)}\`);
-};
-
-const generatedWorkspaceToolInteractions = Object.fromEntries(
-  generatedWorkspaceToolNames.map((name) => [name, generatedWorkspaceToolInteractionFor(name)]),
-) as Readonly<Partial<Record<(typeof generatedWorkspaceToolNames)[number], "never" | "approval">>>;
-
 const workspaceNamespaceFor = (env: AgentOSTargetEnv): DurableObjectNamespace<Sandbox> =>
   env[${jsString(normalized.workspace.binding)}] as DurableObjectNamespace<Sandbox>;
 
@@ -221,36 +1005,46 @@ const workspaceEnvFor = (env: AgentOSTargetEnv) =>
     workspaceRef: ${jsString(normalized.workspace.providerResourceId)},
   });
 
-const allowWorkspaceTool = () =>
-  Effect.succeed({ ok: true as const }).pipe(
-    Effect.withSpan("agentos.generated.workspace.allow_tool"),
-  );
+const generatedHostProfileFor = (env: AgentOSTargetEnv) => defineHost({
+  target: "cloudflare-do@1",
+  provides: [
+    "storage.ledger",
+    "durability.do",
+    WORKSPACE_OPERATION_HOST_FACT,
+    "timer.durable",
+    "network.outbound",
+    "secrets.store",
+    "eventLoop.durable",
+    "llm.openai",
+  ],
+  materialize: () => ({
+    [WORKSPACE_OPERATION_HOST_FACT]: () => workspaceEnvFor(env),
+  }),
+});
 
-const workspaceOperationInstallFor = (env: AgentOSTargetEnv) =>
-  installCloudflareWorkspaceOperationProvider({
-    env: workspaceEnvFor(env),
-  });
+const generatedCapabilityInstallGraphFor = (env: AgentOSTargetEnv) => {
+  const graph = resolveRuntimeInstallGraph(
+    generatedHostProfileFor(env),
+    [workspaceOperations(generatedWorkspaceOperations)],
+    { identity: semanticManifest.agentId },
+  );
+  if (!graph.ok) {
+    throw Error(
+      graph.diagnostics
+        .map((diagnostic) => diagnostic.reason)
+        .join("; ") || "capability install graph failed",
+    );
+  }
+  return graph.resolved;
+};
 
 const materialEnvValue = (env: AgentOSTargetEnv, name: string): string | null => {
   const value = env[name];
   return typeof value === "string" && value.length > 0 ? value : null;
 };
 
-const materialValue = (
-  env: AgentOSTargetEnv,
-  ref: { readonly kind: string; readonly ref: string },
-): NonNullable<unknown> | null => {
-  if (ref.kind === "endpoint" && ref.ref === ${jsString(normalized.llm.endpointRef)}) {
-    return materialEnvValue(env, ${jsString(llmEnvByKind.endpoint)});
-  }
-  if (ref.kind === "credential" && ref.ref === ${jsString(normalized.llm.credentialRef)}) {
-    return materialEnvValue(env, ${jsString(llmEnvByKind.credential)});
-  }
-  if (ref.kind === "model" && ref.ref === ${jsString(normalized.llm.modelRef)}) {
-    return materialEnvValue(env, ${jsString(llmEnvByKind.model)});
-  }
-  return null;
-};
+${renderMaterialValueFunction(normalized.llmRoutes)}
+${renderGeneratedProviderPreflight(normalized.llmRoutes)}
 
 const requiredStringMaterial = (
   kind: string,
@@ -261,70 +1055,45 @@ const requiredStringMaterial = (
   return targetFailure(\`missing \${kind} material: \${ref}\`);
 };
 
-const generatedLlmRouteFor = (env: AgentOSTargetEnv): GeneratedTargetResult<NonNullable<AgentSubmitBindings["llmRoutes"]>["default"]> => {
-  const modelId = requiredStringMaterial(
-    "model",
-    ${jsString(normalized.llm.modelRef)},
-    materialValue(env, { kind: "model", ref: ${jsString(normalized.llm.modelRef)} }),
-  );
-  if (!modelId.ok) return modelId;
-  return {
-    ok: true,
-    value: {
-      kind: "openai-chat-compatible",
-      endpointRef: ${jsString(normalized.llm.endpointRef)},
-      credentialRef: ${jsString(normalized.llm.credentialRef)},
-      modelId: modelId.value,
-    },
-  };
-};
+${renderGeneratedLlmRoutesFor(normalized.llmRoutes)}
 
-const generatedWorkspaceBindingsFor = (env: AgentOSTargetEnv): AgentSubmitBindings =>
-  generatedWorkspaceToolNames.length === 0
-    ? {}
-    : bindWorkspaceToolsForRuntime({
-        env: workspaceEnvFor(env),
-        authority: "agentos.workspace.static-target",
-        admit: allowWorkspaceTool,
-        toolNames: generatedWorkspaceToolNames,
-        mutationPolicy: ${usesMutationTools ? '"receipt-backed"' : '"disabled"'},
-        shellPolicy: ${usesShellTools ? '"receipt-backed"' : '"disabled"'},
-        toolInteractions: generatedWorkspaceToolInteractions,
-      });
-
-const generatedSubmitBindingsFor = (env: AgentOSTargetEnv): GeneratedTargetResult<AgentSubmitBindings> => {
-  const workspaceBindings = generatedWorkspaceBindingsFor(env);
-  const route = generatedLlmRouteFor(env);
-  if (!route.ok) return route;
+const generatedSubmitBindingsFor = async (
+  env: AgentOSTargetEnv,
+  event: DynamicCapabilityEventRef = generatedDynamicCapabilityTurnEvent(),
+  dynamicCapability: DynamicCapabilityRunInput | undefined = undefined,
+): Promise<GeneratedTargetResult<AgentSubmitBindings>> => {
+  const preflightDiagnostics = generatedProviderPreflightDiagnosticsFor(env);
+  if (preflightDiagnostics.length > 0) {
+    return targetFailure(
+      "OpenAI-compatible provider material preflight failed",
+      preflightDiagnostics,
+    );
+  }
+  const capabilityGraph = generatedCapabilityInstallGraphFor(env);
+  const routes = generatedLlmRoutesFor(env);
+  if (!routes.ok) return routes;
+  const dynamicBindings = await generatedDynamicSubmitBindingsFor(event, dynamicCapability);
+  if (!dynamicBindings.ok) return dynamicBindings;
+  const dynamicCapabilityProjection = dynamicBindings.value.dynamicCapabilityProjection;
   return {
     ok: true,
     value: {
-      ...workspaceBindings,
-      llmRoutes: {
-        default: route.value,
-      },
+      ...capabilityGraph.bindings,
+      ...dynamicBindings.value,
+      llmRoutes: routes.value,
       tools: {
-        ...(workspaceBindings.tools ?? {}),
+        ...(capabilityGraph.bindings.tools ?? {}),
         ...generatedCustomTools,
+        ${hasSkills ? "...generatedFrameworkToolsFor(dynamicCapabilityProjection)," : ""}
       },
     },
   };
 };
 
-const submitSpecFromRunInput = (input: SubmitRunInput): AgentSubmitSpec => ({
-  input,
-  intent: input.intent,
-  context: input.context,
-  ...(input.system === undefined ? {} : { system: input.system }),
-  ...(input.budget === undefined ? {} : { budget: input.budget }),
-  ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
-  ...(input.traceContext === undefined ? {} : { traceContext: input.traceContext }),
-  ...(input.materials === undefined ? {} : { materials: input.materials }),
-  ...(input.toolContext === undefined ? {} : { toolContext: input.toolContext }),
-  ...(input.toolPolicy === undefined ? {} : { toolPolicy: input.toolPolicy }),
-  ...(input.decisionInterrupts === undefined ? {} : { decisionInterrupts: input.decisionInterrupts }),
-  ...(input.resume === undefined ? {} : { resume: input.resume }),
-});
+${renderSubmitSpecFromRunInput(hasSkills)}
+
+${renderProductApiHelpers()}
+${hasSchedules ? renderScheduleDurableObjectHelpers() : ""}
 
 export const workspaceMount = defineWorkspaceAgentMount({
   driver: { kind: "driver_mount", client: undefined as never },
@@ -337,22 +1106,24 @@ export const workspaceMount = defineWorkspaceAgentMount({
   ],
 });
 
-const Base${normalized.target.durableObject.className} = createAgentDurableObject<AgentOSTargetEnv>({
+const Base${target.durableObject.className} = createAgentDurableObject<AgentOSTargetEnv>({
   manifest: semanticManifest,
-  agentBindings: {
+  agentBindings: (env) => ({
     handlers: ${handlerRecord},
-  },
+    ...generatedCapabilityInstallGraphFor(env).agentBindings,
+  }),
   refResolver: (env) => ({
     material: (ref) => materialValue(env, ref),
   }),
   llmTransport: () => OpenAiCompatibleLlmTransportLive,
-  extensions: (env) => workspaceOperationInstallFor(env).extensions,
-  declaredIntents: (env) => workspaceOperationInstallFor(env).declaredIntents,
-  projections: (env) => workspaceOperationInstallFor(env).projections,
-  eventHandlers: (context, env) => workspaceOperationInstallFor(env).eventHandlers(context),
+  extensions: (env) => generatedCapabilityInstallGraphFor(env).extensions,
+  declaredIntents: (env) => generatedCapabilityInstallGraphFor(env).declaredIntents,
+  projections: (env) => generatedCapabilityInstallGraphFor(env).projections,
+  graphStatus: (env) => generatedCapabilityInstallGraphFor(env).graphStatus,
+  eventHandlers: (context, env) => generatedCapabilityInstallGraphFor(env).handlers(context),
 });
 
-export class ${normalized.target.durableObject.className} extends Base${normalized.target.durableObject.className} {
+export class ${target.durableObject.className} extends Base${target.durableObject.className} {
   private readonly targetEnv: AgentOSTargetEnv;
 
   constructor(ctx: DurableObjectState, env: AgentOSTargetEnv) {
@@ -361,31 +1132,47 @@ export class ${normalized.target.durableObject.className} extends Base${normaliz
   }
 
   override submit(spec: AgentSubmitSpec): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.submitWithBindings(spec, bindings.value)
-      : rejectTargetFailure(bindings);
+    return generatedSubmitBindingsFor(
+      this.targetEnv,
+      generatedDynamicCapabilityTurnEvent(),
+      spec.dynamicCapability,
+    ).then((bindings) =>
+      bindings.ok ? this.submitWithBindings(spec, bindings.value) : rejectTargetFailure(bindings),
+    );
   }
 
   submitRunInput(input: SubmitRunInput): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.submitWithBindings(submitSpecFromRunInput(input), bindings.value)
-      : rejectTargetFailure(bindings);
+    return generatedSubmitBindingsFor(
+      this.targetEnv,
+      generatedDynamicCapabilityTurnEvent(),
+      input.dynamicCapability,
+    ).then((bindings) =>
+      bindings.ok
+        ? this.submitWithBindings(
+            submitSpecFromRunInput(input, bindings.value.dynamicCapabilityProjection),
+            bindings.value,
+          )
+        : rejectTargetFailure(bindings),
+    );
   }
 
+${renderProductApiDurableObjectMethods()}
+${hasSchedules ? renderScheduleDurableObjectMethod() : ""}
+
   resumeInputRequest(input: WorkspaceAgentResumeInputRequestCommandInput): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.resumeInputRequestWithBindings(input, bindings.value)
-      : rejectTargetFailure(bindings);
+    return generatedSubmitBindingsFor(this.targetEnv).then((bindings) =>
+      bindings.ok
+        ? this.resumeInputRequestWithBindings(input, bindings.value)
+        : rejectTargetFailure(bindings),
+    );
   }
 
   decideInputRequest(input: WorkspaceAgentDecideInputRequestCommandInput): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.decideInputRequestWithBindings(input, bindings.value)
-      : rejectTargetFailure(bindings);
+    return generatedSubmitBindingsFor(this.targetEnv).then((bindings) =>
+      bindings.ok
+        ? this.decideInputRequestWithBindings(input, bindings.value)
+        : rejectTargetFailure(bindings),
+    );
   }
 
   customCommand(input: WorkspaceAgentCustomCommandInput): Promise<unknown> {
@@ -453,6 +1240,10 @@ export class ${normalized.target.durableObject.className} extends Base${normaliz
 `;
 };
 const renderChatStaticTarget = (normalized, toolNames, modules) => {
+    const target = cloudflareTargetFor(normalized.target);
+    const hasSkills = normalized.skills.length > 0;
+    const hasDynamicCapability = true;
+    const hasSchedules = normalized.schedules.length > 0;
     const authoredToolNames = new Set(normalized.authoredToolNames);
     const customToolNames = toolNames.filter((toolName) => authoredToolNames.has(toolName));
     const toolImports = customToolNames
@@ -466,39 +1257,324 @@ const renderChatStaticTarget = (normalized, toolNames, modules) => {
     const handlerRecord = `{\n${normalized.deployment.manifest.handlers
         .map((handler) => `  ${jsString(handler)}: generatedHandler,`)
         .join("\n")}\n}`;
+    const llmEnvBindings = uniqueLlmMaterialEnvBindings(normalized.llmRoutes);
+    const generatedLlmEnvFields = llmEnvBindings
+        .map((binding) => `  readonly ${binding.envName}?: string;`)
+        .join("\n");
+    const imports = [
+        `import semanticDeclarations from "./manifest.json";`,
+        `import deploymentProvenance from "./deployment.json";`,
+        ...(hasSchedules
+            ? [renderNamedImport(["dispatchGeneratedScheduleDelivery"], "./schedules")]
+            : []),
+        renderNamedImport(["createAgentDurableObject"], modules.cloudflareDoRuntime),
+        renderNamedImport(["runDynamicCapabilityResolvers"], modules.runtimeCapability),
+        renderNamedImport(["OpenAiCompatibleLlmTransportLive", "preflightOpenAiCompatibleProviderMaterial"], modules.openAiCompatibleTransport),
+        renderNamedImport(["DYNAMIC_CAPABILITY_EVENT", "manifestTruthIdentity"], modules.runtimeProtocol),
+        renderNamedImport(["projectAgentSession", "projectAgentSessions", "projectWorkflowRun", "projectWorkflowRuns"], modules.runtimeRunProjector),
+        renderNamedImport([
+            "deterministicToolInvocation",
+            ...(hasSkills ? ["defineProductTool"] : []),
+            "unsafeRunToolByName",
+        ], modules.coreTools),
+        renderNamedImport(hasSkills ? ["Effect", "Schema"] : ["Effect"], modules.effect),
+        renderTypeImport(["AgentManifest", "AgentSubmitBindings", "SubmitResult", "SubmitRunInput"], modules.runtimeProtocol),
+        ...(hasDynamicCapability
+            ? [
+                renderTypeImport([
+                    "DynamicCapabilityCompiledCatalog",
+                    "DynamicCapabilityEventRef",
+                    "DynamicCapabilityProjection",
+                    "DynamicCapabilityRunInput",
+                    "SubmitInstructionFragment",
+                ], modules.runtimeProtocol),
+                renderTypeImport(["DynamicCapabilityResolverDefinition"], modules.runtimeCapability),
+            ]
+            : []),
+        renderTypeImport([
+            "AgentSessionListProjection",
+            "AgentSessionProjection",
+            "WorkflowRunListProjection",
+            "WorkflowRunProjection",
+        ], modules.runtimeRunProjector),
+        renderTypeImport(["AgentSubmitSpec"], modules.cloudflareDoRuntime),
+        ...(hasSchedules ? [renderTypeImport(["GeneratedScheduleTriggerInput"], "./schedules")] : []),
+        renderTypeImport([
+            "WorkspaceAgentCustomCommandInput",
+            "WorkspaceAgentDecideInputRequestCommandInput",
+            "WorkspaceAgentResumeInputRequestCommandInput",
+        ], modules.workspaceAgentHost),
+        renderTypeImport(["Tool"], modules.coreTools),
+        ...(toolImports.length === 0 ? [] : [toolImports]),
+    ].join("\n");
+    return `${imports}
+
+export const targetDeclarations = semanticDeclarations;
+export const targetDeployment = deploymentProvenance;
+
+const semanticManifest = semanticDeclarations as AgentManifest;
+const semanticTruthIdentity = manifestTruthIdentity(semanticManifest);
+const generatedHandler = () => undefined;
+
+type AgentOSTargetEnv = {
+  readonly [binding: string]: unknown;
+${generatedLlmEnvFields}
+};
+
+type GeneratedTargetFailure = {
+  readonly ok: false;
+  readonly message: string;
+  readonly diagnostics?: ReturnType<typeof preflightOpenAiCompatibleProviderMaterial>;
+};
+
+type GeneratedTargetResult<Value> =
+  | { readonly ok: true; readonly value: Value }
+  | GeneratedTargetFailure;
+
+const targetFailure = (
+  message: string,
+  diagnostics?: ReturnType<typeof preflightOpenAiCompatibleProviderMaterial>,
+): GeneratedTargetFailure => ({
+  ok: false,
+  message,
+  ...(diagnostics === undefined || diagnostics.length === 0 ? {} : { diagnostics }),
+});
+
+const rejectTargetFailure = (failure: GeneratedTargetFailure): Promise<never> => {
+  const error = Error(failure.message) as Error & {
+    diagnostics?: ReturnType<typeof preflightOpenAiCompatibleProviderMaterial>;
+  };
+  if (failure.diagnostics !== undefined) error.diagnostics = failure.diagnostics;
+  return Promise.reject(error);
+};
+
+const generatedCustomTools = ${customToolRecord} satisfies Readonly<Record<string, Tool>>;
+${renderDynamicCapabilitySupport(normalized, toolNames, hasSkills)}
+${renderSkillSupport(normalized.skills)}
+
+const materialEnvValue = (env: AgentOSTargetEnv, name: string): string | null => {
+  const value = env[name];
+  return typeof value === "string" && value.length > 0 ? value : null;
+};
+
+${renderMaterialValueFunction(normalized.llmRoutes)}
+${renderGeneratedProviderPreflight(normalized.llmRoutes)}
+
+const requiredStringMaterial = (
+  kind: string,
+  ref: string,
+  value: NonNullable<unknown> | null,
+): GeneratedTargetResult<string> => {
+  if (typeof value === "string" && value.length > 0) return { ok: true, value };
+  return targetFailure(\`missing \${kind} material: \${ref}\`);
+};
+
+${renderGeneratedLlmRoutesFor(normalized.llmRoutes)}
+
+const generatedSubmitBindingsFor = async (
+  env: AgentOSTargetEnv,
+  event: DynamicCapabilityEventRef = generatedDynamicCapabilityTurnEvent(),
+  dynamicCapability: DynamicCapabilityRunInput | undefined = undefined,
+): Promise<GeneratedTargetResult<AgentSubmitBindings>> => {
+  const preflightDiagnostics = generatedProviderPreflightDiagnosticsFor(env);
+  if (preflightDiagnostics.length > 0) {
+    return targetFailure(
+      "OpenAI-compatible provider material preflight failed",
+      preflightDiagnostics,
+    );
+  }
+  const routes = generatedLlmRoutesFor(env);
+  if (!routes.ok) return routes;
+  const dynamicBindings = await generatedDynamicSubmitBindingsFor(event, dynamicCapability);
+  if (!dynamicBindings.ok) return dynamicBindings;
+  const dynamicCapabilityProjection = dynamicBindings.value.dynamicCapabilityProjection;
+  return {
+    ok: true,
+    value: {
+      ...dynamicBindings.value,
+      llmRoutes: routes.value,
+      tools: ${hasSkills
+        ? `{
+        ...generatedCustomTools,
+        ...generatedFrameworkToolsFor(dynamicCapabilityProjection),
+      }`
+        : "generatedCustomTools"},
+    },
+  };
+};
+
+${renderSubmitSpecFromRunInput(hasSkills)}
+
+${renderProductApiHelpers()}
+${hasSchedules ? renderScheduleDurableObjectHelpers() : ""}
+
+const Base${target.durableObject.className} = createAgentDurableObject<AgentOSTargetEnv>({
+  manifest: semanticManifest,
+  agentBindings: {
+    handlers: ${handlerRecord},
+  },
+  refResolver: (env) => ({
+    material: (ref) => materialValue(env, ref),
+  }),
+  llmTransport: () => OpenAiCompatibleLlmTransportLive,
+});
+
+export class ${target.durableObject.className} extends Base${target.durableObject.className} {
+  private readonly targetEnv: AgentOSTargetEnv;
+
+  constructor(ctx: DurableObjectState, env: AgentOSTargetEnv) {
+    super(ctx, env);
+    this.targetEnv = env;
+  }
+
+  override submit(spec: AgentSubmitSpec): Promise<SubmitResult> {
+    return generatedSubmitBindingsFor(
+      this.targetEnv,
+      generatedDynamicCapabilityTurnEvent(),
+      spec.dynamicCapability,
+    ).then((bindings) =>
+      bindings.ok ? this.submitWithBindings(spec, bindings.value) : rejectTargetFailure(bindings),
+    );
+  }
+
+  submitRunInput(input: SubmitRunInput): Promise<SubmitResult> {
+    return generatedSubmitBindingsFor(
+      this.targetEnv,
+      generatedDynamicCapabilityTurnEvent(),
+      input.dynamicCapability,
+    ).then((bindings) =>
+      bindings.ok
+        ? this.submitWithBindings(
+            submitSpecFromRunInput(input, bindings.value.dynamicCapabilityProjection),
+            bindings.value,
+          )
+        : rejectTargetFailure(bindings),
+    );
+  }
+
+${renderProductApiDurableObjectMethods()}
+${hasSchedules ? renderScheduleDurableObjectMethod() : ""}
+
+  resumeInputRequest(input: WorkspaceAgentResumeInputRequestCommandInput): Promise<SubmitResult> {
+    return generatedSubmitBindingsFor(this.targetEnv).then((bindings) =>
+      bindings.ok
+        ? this.resumeInputRequestWithBindings(input, bindings.value)
+        : rejectTargetFailure(bindings),
+    );
+  }
+
+  decideInputRequest(input: WorkspaceAgentDecideInputRequestCommandInput): Promise<SubmitResult> {
+    return generatedSubmitBindingsFor(this.targetEnv).then((bindings) =>
+      bindings.ok
+        ? this.decideInputRequestWithBindings(input, bindings.value)
+        : rejectTargetFailure(bindings),
+    );
+  }
+
+  customCommand(input: WorkspaceAgentCustomCommandInput): Promise<unknown> {
+    return Effect.runPromise(
+      unsafeRunToolByName(
+        generatedCustomTools,
+        deterministicToolInvocation(input.method, input.input),
+      ),
+    );
+  }
+}
+`;
+};
+const renderLocalAgentApp = (normalized, toolNames, modules) => {
+    if (normalized.target.kind !== AGENTOS_CONFIG_TARGET.NODE_V1) {
+        throw new TypeError(`local agent app renderer received ${normalized.target.kind}`);
+    }
+    const hasChannels = normalized.channels.length > 0;
+    const hasSkills = normalized.skills.length > 0;
+    const hasSchedules = normalized.schedules.length > 0;
+    const authoredToolNames = new Set(normalized.authoredToolNames);
+    const workspaceToolList = toolNames.filter((toolName) => isWorkspaceToolName(toolName) && !authoredToolNames.has(toolName));
+    const customToolNames = toolNames.filter((toolName) => authoredToolNames.has(toolName));
+    const toolImports = customToolNames
+        .map((toolName, index) => `import tool_${index} from ${jsString(importToolPath(toolName))};`)
+        .join("\n");
+    const customToolRecord = customToolNames.length === 0
+        ? "{}"
+        : `{\n${customToolNames
+            .map((toolName, index) => `  ${jsString(toolName)}: tool_${index},`)
+            .join("\n")}\n}`;
+    const workspaceToolArray = `[${workspaceToolList.map(jsString).join(", ")}] as const`;
+    const usesMutationTools = workspaceToolList.some((toolName) => workspaceMutationToolNames.has(toolName));
+    const usesShellTools = workspaceToolList.some((toolName) => workspaceShellToolNames.has(toolName));
     const llmEnvByKind = Object.fromEntries(llmMaterialEnvBindings(normalized.llm).map((binding) => [binding.kind, binding.envName]));
-    const generatedLlmEnvFields = Object.values(llmEnvByKind)
-        .map((envName) => `  readonly ${envName}?: string;`)
-        .join("\n");
     const imports = [
         `import semanticDeclarations from "./manifest.json";`,
-        `import deploymentProvenance from "./deployment.json";`,
-        renderNamedImport(["createAgentDurableObject"], modules.cloudflareDoRuntime),
-        renderNamedImport(["OpenAiCompatibleLlmTransportLive"], modules.openAiCompatibleTransport),
-        renderNamedImport(["deterministicToolInvocation", "unsafeRunToolByName"], modules.coreTools),
-        renderNamedImport(["Effect"], modules.effect),
-        renderTypeImport(["AgentManifest", "AgentSubmitBindings", "SubmitResult", "SubmitRunInput"], modules.runtimeProtocol),
-        renderTypeImport(["AgentSubmitSpec"], modules.cloudflareDoRuntime),
+        ...(hasChannels ? [renderNamedImport(["dispatchGeneratedChannelRequest"], "./channels")] : []),
+        ...(hasChannels ? [renderTypeImport(["ChannelRuntime"], modules.runtimeChannel)] : []),
+        ...(hasSchedules
+            ? [
+                renderNamedImport([
+                    "dispatchGeneratedScheduleDelivery",
+                    "generatedScheduleDefinitions",
+                    "generatedScheduleIds",
+                ], "./schedules"),
+            ]
+            : []),
+        ...(hasSchedules ? [renderTypeImport(["GeneratedScheduleTriggerInput"], "./schedules")] : []),
+        renderNamedImport(["lowerLocalAgentRuntime"], modules.localRuntime),
+        renderNamedImport(["runDynamicCapabilityResolvers"], modules.runtimeCapability),
+        ...(hasSchedules
+            ? [renderNamedImport(["projectScheduleFireHistory"], modules.runtimeSchedule)]
+            : []),
+        renderNamedImport(["DYNAMIC_CAPABILITY_EVENT", "manifestTruthIdentity"], modules.runtimeProtocol),
+        renderNamedImport(["OpenAiCompatibleLlmTransportLive", "preflightOpenAiCompatibleProviderMaterial"], modules.openAiCompatibleTransport),
+        renderNamedImport([
+            "projectAgentSession",
+            "projectAgentSessions",
+            "projectRunInspection",
+            "projectWorkflowRun",
+            "projectWorkflowRuns",
+        ], modules.runtimeRunProjector),
+        renderTypeImport(["AgentManifest", "SubmitResult", "SubmitRunInput"], modules.runtimeProtocol),
         renderTypeImport([
-            "WorkspaceAgentCustomCommandInput",
-            "WorkspaceAgentDecideInputRequestCommandInput",
-            "WorkspaceAgentResumeInputRequestCommandInput",
-        ], modules.workspaceAgentHost),
+            "AgentSubmitBindings",
+            "DynamicCapabilityCompiledCatalog",
+            "DynamicCapabilityEventRef",
+            "DynamicCapabilityProjection",
+            "DynamicCapabilityRunInput",
+            "SubmitInstructionFragment",
+        ], modules.runtimeProtocol),
+        renderTypeImport(["DynamicCapabilityResolverDefinition"], modules.runtimeCapability),
+        ...(hasSchedules
+            ? [
+                renderTypeImport([
+                    "ScheduleDefinitionProjection",
+                    "ScheduleFireHistoryProjection",
+                    "ScheduleFireProjection",
+                ], modules.runtimeSchedule),
+            ]
+            : []),
+        renderTypeImport([
+            "AgentSessionListProjection",
+            "AgentSessionProjection",
+            "RunInspection",
+            "WorkflowRunListProjection",
+            "WorkflowRunProjection",
+        ], modules.runtimeRunProjector),
+        renderTypeImport(["CreateLocalAgentRuntimeOptions", "LocalAgentRuntime", "LocalAgentSubmitInput"], modules.localRuntime),
+        renderTypeImport(["WorkspaceAgentCustomCommandInput"], modules.workspaceAgentHost),
+        renderNamedImport([
+            ...(hasSkills ? ["defineProductTool"] : []),
+            "deterministicToolInvocation",
+            "unsafeRunToolByName",
+        ], modules.coreTools),
+        renderNamedImport(hasSkills ? ["Effect", "Schema"] : ["Effect"], modules.effect),
         renderTypeImport(["Tool"], modules.coreTools),
         ...(toolImports.length === 0 ? [] : [toolImports]),
     ].join("\n");
     return `${imports}
 
-export const targetDeclarations = semanticDeclarations;
-export const targetDeployment = deploymentProvenance;
-
 const semanticManifest = semanticDeclarations as AgentManifest;
-const generatedHandler = () => undefined;
+const semanticTruthIdentity = manifestTruthIdentity(semanticManifest);
 
-type AgentOSTargetEnv = {
-  readonly [binding: string]: unknown;
-${generatedLlmEnvFields}
-};
+type AgentOSTargetEnv = Readonly<Record<string, string | undefined>>;
 
 type GeneratedTargetFailure = {
   readonly ok: false;
@@ -509,12 +1585,33 @@ type GeneratedTargetResult<Value> =
   | { readonly ok: true; readonly value: Value }
   | GeneratedTargetFailure;
 
-const targetFailure = (message: string): GeneratedTargetFailure => ({ ok: false, message });
+const targetFailure = (message: string): GeneratedTargetFailure => ({
+  ok: false,
+  message,
+});
 
 const rejectTargetFailure = (failure: GeneratedTargetFailure): Promise<never> =>
   Promise.reject(Error(failure.message));
 
+${renderGeneratedWorkspaceOperations(workspaceToolArray, usesMutationTools, usesShellTools)}
 const generatedCustomTools = ${customToolRecord} satisfies Readonly<Record<string, Tool>>;
+${renderDynamicCapabilitySupport(normalized, toolNames, hasSkills)}
+${renderSkillSupport(normalized.skills)}
+
+const cleanEnv = (source: AgentOSTargetEnv): Record<string, string> => {
+  const env: Record<string, string> = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== undefined) env[key] = value;
+  }
+  return env;
+};
+
+const generatedTargetEnvFor = (
+  options: Pick<CreateLocalAgentAppOptions, "env" | "inheritEnv">,
+): AgentOSTargetEnv => ({
+  ...(options.inheritEnv === true ? cleanEnv(process.env) : {}),
+  ...(options.env === undefined ? {} : cleanEnv(options.env)),
+});
 
 const materialEnvValue = (env: AgentOSTargetEnv, name: string): string | null => {
   const value = env[name];
@@ -537,124 +1634,221 @@ const materialValue = (
   return null;
 };
 
-const requiredStringMaterial = (
-  kind: string,
-  ref: string,
-  value: NonNullable<unknown> | null,
-): GeneratedTargetResult<string> => {
-  if (typeof value === "string" && value.length > 0) return { ok: true, value };
-  return targetFailure(\`missing \${kind} material: \${ref}\`);
-};
-
-const generatedLlmRouteFor = (env: AgentOSTargetEnv): GeneratedTargetResult<NonNullable<AgentSubmitBindings["llmRoutes"]>["default"]> => {
-  const modelId = requiredStringMaterial(
-    "model",
-    ${jsString(normalized.llm.modelRef)},
-    materialValue(env, { kind: "model", ref: ${jsString(normalized.llm.modelRef)} }),
-  );
-  if (!modelId.ok) return modelId;
+const generatedLocalLlmFor = (
+  env: AgentOSTargetEnv,
+): NonNullable<CreateLocalAgentRuntimeOptions["llm"]> => {
+  const modelValue = materialValue(env, { kind: "model", ref: ${jsString(normalized.llm.modelRef)} });
   return {
-    ok: true,
-    value: {
+    kind: "transport",
+    transport: OpenAiCompatibleLlmTransportLive,
+    route: {
       kind: "openai-chat-compatible",
       endpointRef: ${jsString(normalized.llm.endpointRef)},
       credentialRef: ${jsString(normalized.llm.credentialRef)},
-      modelId: modelId.value,
+      modelId: typeof modelValue === "string" ? modelValue : "",
+    },
+    refResolver: {
+      material: (ref) => materialValue(env, ref),
     },
+    preflight: preflightOpenAiCompatibleProviderMaterial,
   };
 };
 
-const generatedSubmitBindingsFor = (env: AgentOSTargetEnv): GeneratedTargetResult<AgentSubmitBindings> => {
-  const route = generatedLlmRouteFor(env);
-  if (!route.ok) return route;
+${renderProductApiHelpers()}
+
+const generatedLocalSubmitInputFromRunInput = async (
+  input: SubmitRunInput,
+  event: DynamicCapabilityEventRef = generatedDynamicCapabilityTurnEvent(),
+): Promise<LocalAgentSubmitInput> => {
+  const dynamicBindings = await generatedDynamicSubmitBindingsFor(event, input.dynamicCapability);
+  if (!dynamicBindings.ok) return rejectTargetFailure(dynamicBindings);
+  const dynamicCapabilityProjection = dynamicBindings.value.dynamicCapabilityProjection;
   return {
-    ok: true,
-    value: {
-      llmRoutes: {
-        default: route.value,
-      },
-      tools: generatedCustomTools,
-    },
+    ...input,
+    ...(input.context === undefined ? {} : { context: input.context }),
+    ...(input.system === undefined && !${hasSkills} ? {} : {
+      system: ${hasSkills ? "generatedSystemPrompt(input.system, dynamicCapabilityProjection)" : "input.system"},
+    }),
+    dynamicCapabilityProjection,
+    instructionFragments: dynamicBindings.value.instructionFragments,
+    tools: ${hasSkills
+        ? `{
+      ...generatedCustomTools,
+      ...generatedFrameworkToolsFor(dynamicCapabilityProjection),
+    }`
+        : "generatedCustomTools"},
   };
 };
 
-const submitSpecFromRunInput = (input: SubmitRunInput): AgentSubmitSpec => ({
-  input,
-  intent: input.intent,
-  context: input.context,
-  ...(input.system === undefined ? {} : { system: input.system }),
-  ...(input.budget === undefined ? {} : { budget: input.budget }),
-  ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
-  ...(input.traceContext === undefined ? {} : { traceContext: input.traceContext }),
-  ...(input.materials === undefined ? {} : { materials: input.materials }),
-  ...(input.toolContext === undefined ? {} : { toolContext: input.toolContext }),
-  ...(input.toolPolicy === undefined ? {} : { toolPolicy: input.toolPolicy }),
-  ...(input.decisionInterrupts === undefined ? {} : { decisionInterrupts: input.decisionInterrupts }),
-  ...(input.resume === undefined ? {} : { resume: input.resume }),
-});
-
-const Base${normalized.target.durableObject.className} = createAgentDurableObject<AgentOSTargetEnv>({
-  manifest: semanticManifest,
-  agentBindings: {
-    handlers: ${handlerRecord},
-  },
-  refResolver: (env) => ({
-    material: (ref) => materialValue(env, ref),
-  }),
-  llmTransport: () => OpenAiCompatibleLlmTransportLive,
-});
-
-export class ${normalized.target.durableObject.className} extends Base${normalized.target.durableObject.className} {
-  private readonly targetEnv: AgentOSTargetEnv;
-
-  constructor(ctx: DurableObjectState, env: AgentOSTargetEnv) {
-    super(ctx, env);
-    this.targetEnv = env;
-  }
-
-  override submit(spec: AgentSubmitSpec): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.submitWithBindings(spec, bindings.value)
-      : rejectTargetFailure(bindings);
-  }
-
-  submitRunInput(input: SubmitRunInput): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.submitWithBindings(submitSpecFromRunInput(input), bindings.value)
-      : rejectTargetFailure(bindings);
-  }
+export interface LocalAgentAppRuntime extends LocalAgentRuntime {
+  readonly inspectRun: (runId: number | string) => RunInspection;
+}
 
-  resumeInputRequest(input: WorkspaceAgentResumeInputRequestCommandInput): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.resumeInputRequestWithBindings(input, bindings.value)
-      : rejectTargetFailure(bindings);
-  }
+export interface LocalAgentApp {
+  readonly runtime: LocalAgentAppRuntime;
+  readonly sessions: {
+    readonly submitTurn: (input: AgentSessionSubmitTurnInput) => Promise<SubmitResult>;
+    readonly inspect: (sessionRef: string) => AgentSessionProjection;
+    readonly list: () => AgentSessionListProjection;
+  };
+  readonly workflows: {
+    readonly run: (input: AgentWorkflowRunInput) => Promise<SubmitResult>;
+    readonly inspectRun: (
+      workflowId: string,
+      workflowRunId: string,
+    ) => WorkflowRunProjection | null;
+    readonly listRuns: (workflowId: string) => WorkflowRunListProjection;
+  };
+  ${hasChannels
+        ? `readonly channels: {
+    readonly handle: (request: Request) => Promise<Response | null>;
+  };`
+        : ""}
+  readonly customCommand: (input: WorkspaceAgentCustomCommandInput) => Promise<unknown>;
+  ${hasSchedules
+        ? `readonly schedules: {
+    readonly ids: ReadonlyArray<string>;
+    readonly list: () => ReadonlyArray<ScheduleDefinitionProjection>;
+    readonly trigger: (input: GeneratedScheduleTriggerInput) => Promise<ScheduleFireProjection>;
+    readonly history: (input?: { readonly scheduleId?: string }) => ScheduleFireHistoryProjection;
+  };`
+        : ""}
+}
 
-  decideInputRequest(input: WorkspaceAgentDecideInputRequestCommandInput): Promise<SubmitResult> {
-    const bindings = generatedSubmitBindingsFor(this.targetEnv);
-    return bindings.ok
-      ? this.decideInputRequestWithBindings(input, bindings.value)
-      : rejectTargetFailure(bindings);
-  }
+${hasChannels
+        ? `export const handleLocalAgentChannelRequest = (
+  request: Request,
+  runtime: ChannelRuntime,
+): Promise<Response | null> => dispatchGeneratedChannelRequest(request, runtime);`
+        : ""}
+
+export interface CreateLocalAgentAppOptions {
+  readonly cwd?: string;
+  readonly env?: CreateLocalAgentRuntimeOptions["env"];
+  readonly inheritEnv?: CreateLocalAgentRuntimeOptions["inheritEnv"];
+  readonly llm?: CreateLocalAgentRuntimeOptions["llm"];
+}
 
-  customCommand(input: WorkspaceAgentCustomCommandInput): Promise<unknown> {
-    return Effect.runPromise(
+export const createLocalAgentApp = async (
+  options: CreateLocalAgentAppOptions = {},
+): Promise<LocalAgentApp> => {
+  const targetEnv = generatedTargetEnvFor(options);
+  const lowered = await lowerLocalAgentRuntime({
+    target: "node@1",
+    identity: semanticManifest.agentId,
+    truthIdentity: semanticTruthIdentity,
+    cwd: options.cwd ?? process.cwd(),
+    ...(options.env === undefined ? {} : { env: options.env }),
+    ...(options.inheritEnv === undefined ? {} : { inheritEnv: options.inheritEnv }),
+    llm: options.llm ?? generatedLocalLlmFor(targetEnv),
+    workspaceOperations: generatedWorkspaceOperations,
+  });
+  const sessions = {
+    submitTurn: (input: AgentSessionSubmitTurnInput) =>
+      generatedLocalSubmitInputFromRunInput(
+        submitRunInputFromSessionTurn(input),
+        generatedDynamicCapabilityTurnEvent({
+          sessionRef: input.sessionRef,
+          turnRef: input.turnRef,
+        }),
+      ).then((submitInput) =>
+        lowered.submitWithProductLink(submitInput, {
+          kind: "session_turn",
+          sessionRef: input.sessionRef,
+          turnRef: input.turnRef,
+          ...(input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }),
+        }),
+      ),
+    inspect: (sessionRef: string) => projectAgentSession(lowered.runtime.events(), sessionRef),
+    list: () => projectAgentSessions(lowered.runtime.events()),
+  };
+  const workflows = {
+    run: (input: AgentWorkflowRunInput) =>
+      generatedLocalSubmitInputFromRunInput(submitRunInputFromWorkflowRun(input)).then(
+        (submitInput) =>
+          lowered.submitWithProductLink(submitInput, {
+            kind: "workflow_run",
+            workflowId: input.workflowId,
+            workflowRunId: input.workflowRunId,
+            ...(input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }),
+            ...(input.inputDigest === undefined ? {} : { inputDigest: input.inputDigest }),
+          }),
+      ),
+    inspectRun: (workflowId: string, workflowRunId: string) =>
+      projectWorkflowRun(lowered.runtime.events(), workflowId, workflowRunId),
+    listRuns: (workflowId: string) => projectWorkflowRuns(lowered.runtime.events(), workflowId),
+  };
+  const runtime: LocalAgentAppRuntime = {
+    ...lowered.runtime,
+    inspectRun: (runId) =>
+      projectRunInspection(lowered.runtime.events(), runId, lowered.runtime.diagnostics()),
+  };
+  ${hasChannels
+        ? `const channelRuntime: ChannelRuntime = {
+    submit: (input) => lowered.runtime.submit(input),
+    dispatch: async () => {
+      throw new Error("local node channel dispatch is unavailable");
+    },
+  };
+  const channels = {
+    handle: (request: Request) => handleLocalAgentChannelRequest(request, channelRuntime),
+  };`
+        : ""}
+  const customCommand = (input: WorkspaceAgentCustomCommandInput): Promise<unknown> =>
+    Effect.runPromise(
       unsafeRunToolByName(
         generatedCustomTools,
         deterministicToolInvocation(input.method, input.input),
       ),
     );
-  }
-}
+  ${hasSchedules
+        ? `const scheduleHistory = (
+    input: { readonly scheduleId?: string } = {},
+  ): ScheduleFireHistoryProjection => projectScheduleFireHistory(lowered.runtime.events(), input);
+  const triggerSchedule = async (
+    input: GeneratedScheduleTriggerInput,
+  ): Promise<ScheduleFireProjection> => {
+    const result = await dispatchGeneratedScheduleDelivery({
+      ...input,
+      history: lowered.runtime.events(),
+      identity: semanticTruthIdentity,
+      runtime: { sessions, workflows },
+    });
+    if (result.kind === "attempt") {
+      await lowered.commitScheduleFireDispatchWithDelivery(result);
+    }
+    const projected = scheduleHistory({ scheduleId: input.scheduleId }).fires.find(
+      (fire) => fire.fireId === result.fireId,
+    );
+    if (projected === undefined) {
+      throw new Error(\`schedule fire projection missing after commit: \${result.fireId}\`);
+    }
+    return projected;
+  };`
+        : ""}
+  return {
+    runtime,
+    sessions,
+    workflows,
+    ${hasChannels ? "channels,\n    " : ""}customCommand,
+    ${hasSchedules
+        ? `schedules: {
+      ids: generatedScheduleIds,
+      list: () => generatedScheduleDefinitions,
+      trigger: triggerSchedule,
+      history: scheduleHistory,
+    },`
+        : ""}
+  };
+};
 `;
 };
 const renderStaticTarget = (normalized, toolNames, modules) => normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1
     ? renderWorkspaceStaticTarget(normalized, toolNames, modules)
     : renderChatStaticTarget(normalized, toolNames, modules);
-const renderCloudflareScopeHelper = (normalized, modules) => `${renderNamedImport(["durableObjectRpcClient"], `${modules.cloudflareDoRuntime}/do-rpc`)}
+const renderCloudflareScopeHelper = (normalized, modules) => {
+    const target = cloudflareTargetFor(normalized.target);
+    return `${renderNamedImport(["durableObjectRpcClient"], `${modules.cloudflareDoRuntime}/do-rpc`)}
 ${renderNamedImport(["manifestTruthIdentity"], modules.runtimeProtocol)}
 ${renderTypeImport(["AgentRuntimeClient"], modules.cloudflareDoRuntime)}
 ${renderTypeImport(["DurableObjectRpcClient"], `${modules.cloudflareDoRuntime}/do-rpc`)}
@@ -667,7 +1861,7 @@ export type AgentOSTargetEnv = {
 
 export const agentOSTruthIdentity = manifestTruthIdentity(manifest as AgentManifest);
 export const agentOSScopeId = agentOSTruthIdentity.scopeRef.scopeId;
-export const agentOSDurableObjectBinding = ${jsString(normalized.target.durableObject.binding)};
+export const agentOSDurableObjectBinding = ${jsString(target.durableObject.binding)};
 
 export const agentOSDurableObjectNamespace = (
   env: AgentOSTargetEnv,
@@ -681,18 +1875,79 @@ export const agentOSRpcClient = <
   scopeId: string = agentOSScopeId,
 ): DurableObjectRpcClient<Rpc> => durableObjectRpcClient<Rpc>(agentOSDurableObjectNamespace(env), scopeId);
 `;
-const renderCloudflareWorkerEntry = (normalized, modules) => `${normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1 ? `${renderNamedImport(["Sandbox"], modules.cloudflareSandbox)}\n` : ""}${renderNamedImport([normalized.target.durableObject.className], "./target")}
-${renderTypeImport(["AgentOSTargetEnv"], "./cloudflare-scope")}
+};
+const renderCloudflareWorkerEntry = (normalized, modules) => {
+    const target = cloudflareTargetFor(normalized.target);
+    const hasChannels = normalized.channels.length > 0;
+    const hasSchedules = normalized.schedules.length > 0;
+    const cloudflareScopeImports = [
+        ...(hasChannels || hasSchedules ? ["agentOSRpcClient"] : []),
+        ...(hasSchedules ? ["agentOSScopeId"] : []),
+    ];
+    return `${normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1 ? `${renderNamedImport(["Sandbox"], modules.cloudflareSandbox)}\n` : ""}${renderNamedImport([target.durableObject.className], "./target")}
+${hasChannels ? `${renderNamedImport(["dispatchGeneratedChannelRequest"], "./channels")}\n${renderTypeImport(["AgentRuntimeClient"], modules.cloudflareDoRuntime)}\n${renderTypeImport(["ChannelRuntime"], modules.runtimeChannel)}\n` : ""}${hasSchedules ? `${renderNamedImport(["generatedSchedules"], "./schedules")}\n${renderTypeImport(["GeneratedScheduleTriggerInput"], "./schedules")}\n` : ""}${cloudflareScopeImports.length === 0 ? "" : `${renderNamedImport(cloudflareScopeImports, "./cloudflare-scope")}\n`}${renderTypeImport(["AgentOSTargetEnv"], "./cloudflare-scope")}
+
+export { ${target.durableObject.className}${normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1 ? ", Sandbox" : ""} };
 
-export { ${normalized.target.durableObject.className}${normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1 ? ", Sandbox" : ""} };
+${hasChannels
+        ? `type AgentOSChannelRpc = Pick<AgentRuntimeClient, "events" | "streamEvents"> & {
+  readonly submitRunInput: ChannelRuntime["submit"];
+  readonly dispatchToScope: ChannelRuntime["dispatch"];
+};
+
+const generatedChannelRuntimeFor = (env: AgentOSTargetEnv): ChannelRuntime => {
+  const runtime = agentOSRpcClient<AgentOSChannelRpc>(env);
+  return Object.freeze({
+    submit: (input) => runtime.submitRunInput(input),
+    dispatch: (spec) => runtime.dispatchToScope(spec),
+  });
+};
+`
+        : ""}
+${hasSchedules
+        ? `type AgentOSScheduleRpc = {
+  readonly dispatchSchedule: (input: GeneratedScheduleTriggerInput) => Promise<unknown>;
+};
+
+const generatedScheduleAppPrincipal: GeneratedScheduleTriggerInput["appPrincipal"] = {
+  authority: "agentos.app",
+  subject: agentOSScopeId,
+};
+
+const generatedScheduleInputsFor = (
+  controller: ScheduledController,
+): ReadonlyArray<GeneratedScheduleTriggerInput> =>
+  generatedSchedules
+    .filter((entry) => entry.cron === controller.cron)
+    .map((entry) => ({
+      scheduleId: entry.scheduleId,
+      scheduledAt: controller.scheduledTime,
+      appPrincipal: generatedScheduleAppPrincipal,
+    }));
+`
+        : ""}
 
 export default {
-  fetch(): Response {
+  async fetch(request: Request, env: AgentOSTargetEnv): Promise<Response> {
+    ${hasChannels
+        ? `const channelResponse = await dispatchGeneratedChannelRequest(request, generatedChannelRuntimeFor(env));
+    if (channelResponse !== null) return channelResponse;`
+        : ""}
     return new Response("agentOS Cloudflare target", { status: 404 });
   },
+  ${hasSchedules
+        ? `scheduled(controller: ScheduledController, env: AgentOSTargetEnv, ctx: ExecutionContext): void {
+    const runtime = agentOSRpcClient<AgentOSScheduleRpc>(env);
+    for (const input of generatedScheduleInputsFor(controller)) {
+      ctx.waitUntil(runtime.dispatchSchedule(input));
+    }
+  },`
+        : ""}
 } satisfies ExportedHandler<AgentOSTargetEnv>;
 `;
+};
 const renderCloudflareWranglerConfig = (normalized) => {
+    const target = cloudflareTargetFor(normalized.target);
     const workspaceConfig = normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1
         ? {
             vars: {
@@ -713,15 +1968,15 @@ const renderCloudflareWranglerConfig = (normalized) => {
                         name: normalized.workspace.binding,
                     },
                     {
-                        class_name: normalized.target.durableObject.className,
-                        name: normalized.target.durableObject.binding,
+                        class_name: target.durableObject.className,
+                        name: target.durableObject.binding,
                     },
                 ],
             },
             migrations: [
                 {
                     tag: "v1",
-                    new_sqlite_classes: ["Sandbox", normalized.target.durableObject.className],
+                    new_sqlite_classes: ["Sandbox", target.durableObject.className],
                 },
             ],
         }
@@ -729,15 +1984,15 @@ const renderCloudflareWranglerConfig = (normalized) => {
             durable_objects: {
                 bindings: [
                     {
-                        class_name: normalized.target.durableObject.className,
-                        name: normalized.target.durableObject.binding,
+                        class_name: target.durableObject.className,
+                        name: target.durableObject.binding,
                     },
                 ],
             },
             migrations: [
                 {
                     tag: "v1",
-                    new_sqlite_classes: [normalized.target.durableObject.className],
+                    new_sqlite_classes: [target.durableObject.className],
                 },
             ],
         };
@@ -759,6 +2014,11 @@ const generatedClientModuleImports = (normalized, modules) => [
                 "createWorkspaceAgentClientBridge",
                 "CreateWorkspaceAgentClientOptions",
                 "WorkspaceAgentClientBridge",
+                "WorkspaceAgentProductClient",
+                "WorkspaceAgentProductCommandMap",
+                "WorkspaceAgentProductProjectionTypes",
+                "WorkspaceAgentProductCommandOutputByName",
+                "WORKSPACE_AGENT_PRODUCT_COMMAND",
             ]
             : [
                 "WORKSPACE_AGENT_COMMAND",
@@ -807,11 +2067,18 @@ const renderWorkspaceSvelteKitRemote = (normalized, modules) => `${renderNamedIm
 ${renderNamedImport(["decodeSseHttpEvents", "responseToSseHttpChunks"], modules.sseHttp)}
 ${renderNamedImport(["Result", "Schema"], modules.effect)}
 ${renderNamedImport(["WORKSPACE_AGENT_COMMAND"], modules.workspaceAgentHost)}
+${renderNamedImport(["WORKSPACE_AGENT_PRODUCT_COMMAND"], modules.workspaceAgentClient)}
 ${renderNamedImport(["decodeRuntimeLedgerEvent", "isInputRequestRef", "parseInputRequestResumePayload"], modules.runtimeProtocol)}
 ${renderNamedImport(["agentOSRpcClient", "agentOSTruthIdentity"], "./cloudflare-scope")}
 ${renderTypeImport(["AgentRuntimeClient"], modules.cloudflareDoRuntime)}
 ${renderTypeImport(["SseHttpEvent"], modules.sseHttp)}
 ${renderTypeImport(["RuntimeLedgerEvent", "SubmitResult", "SubmitRunInput"], modules.runtimeProtocol)}
+${renderTypeImport([
+    "AgentSessionListProjection",
+    "AgentSessionProjection",
+    "WorkflowRunListProjection",
+    "WorkflowRunProjection",
+], modules.runtimeRunProjector)}
 ${renderTypeImport([
     "WorkspaceAgentCustomCommandInput",
     "WorkspaceAgentDestroyCommandInput",
@@ -822,10 +2089,28 @@ ${renderTypeImport([
     "WorkspaceAgentReadStateCommandInput",
     "WorkspaceAgentResetCommandInput",
 ], modules.workspaceAgentHost)}
+${renderTypeImport([
+    "WorkspaceAgentSessionSubmitTurnInput",
+    "WorkspaceAgentWorkflowRunInput",
+    "WorkspaceAgentWorkflowRunRef",
+    "WorkspaceAgentWorkflowRunsInput",
+], modules.workspaceAgentClient)}
 ${renderTypeImport(["AgentOSTargetEnv"], "./cloudflare-scope")}
 
 type AgentOSRpc = Pick<AgentRuntimeClient, "events" | "streamEvents"> & {
   readonly submitRunInput: (input: SubmitRunInput) => Promise<SubmitResult>;
+  readonly submitSessionTurn: (input: WorkspaceAgentSessionSubmitTurnInput) => Promise<SubmitResult>;
+  readonly inspectSession: (
+    input: { readonly sessionRef: string },
+  ) => Promise<AgentSessionProjection>;
+  readonly listSessions: () => Promise<AgentSessionListProjection>;
+  readonly runWorkflow: (input: WorkspaceAgentWorkflowRunInput) => Promise<SubmitResult>;
+  readonly inspectWorkflowRun: (
+    input: WorkspaceAgentWorkflowRunRef,
+  ) => Promise<WorkflowRunProjection | null>;
+  readonly listWorkflowRuns: (
+    input: WorkspaceAgentWorkflowRunsInput,
+  ) => Promise<WorkflowRunListProjection>;
   readonly resumeInputRequest: (
     input: WorkspaceAgentResumeInputRequestCommandInput,
   ) => Promise<SubmitResult>;
@@ -908,6 +2193,78 @@ const submitInputFromUnknown = (
   return { ok: true, value: { input: value.input as unknown as AgentOSSubmitRunInput } };
 };
 
+const productSubmitInputFromUnknown = (
+  value: unknown,
+  label: string,
+): GeneratedResult<AgentOSSubmitRunInput> => {
+  if (!isRecord(value)) return fail(400, \`invalid \${label} command input\`);
+  if (typeof value.intent !== "string" || !isRecord(value.context)) {
+    return fail(400, \`invalid \${label} submit run input\`);
+  }
+  return { ok: true, value: value as unknown as AgentOSSubmitRunInput };
+};
+
+const sessionTurnInputFromUnknown = (
+  value: unknown,
+): GeneratedResult<WorkspaceAgentSessionSubmitTurnInput> => {
+  const submitInput = productSubmitInputFromUnknown(value, "submitSessionTurn");
+  if (!submitInput.ok) return submitInput;
+  if (!isRecord(value)) return fail(400, "invalid submitSessionTurn command input");
+  if (typeof value.sessionRef !== "string" || typeof value.turnRef !== "string") {
+    return fail(400, "invalid session turn identity");
+  }
+  return { ok: true, value: value as unknown as WorkspaceAgentSessionSubmitTurnInput };
+};
+
+const sessionInspectInputFromUnknown = (
+  value: unknown,
+): GeneratedResult<{ readonly sessionRef: string }> => {
+  if (!isRecord(value) || typeof value.sessionRef !== "string") {
+    return fail(400, "invalid inspectSession command input");
+  }
+  return { ok: true, value: { sessionRef: value.sessionRef } };
+};
+
+const workflowRunInputFromUnknown = (
+  value: unknown,
+): GeneratedResult<WorkspaceAgentWorkflowRunInput> => {
+  const submitInput = productSubmitInputFromUnknown(value, "runWorkflow");
+  if (!submitInput.ok) return submitInput;
+  if (!isRecord(value)) return fail(400, "invalid runWorkflow command input");
+  if (typeof value.workflowId !== "string" || typeof value.workflowRunId !== "string") {
+    return fail(400, "invalid workflow run identity");
+  }
+  if (value.idempotencyKey !== undefined && typeof value.idempotencyKey !== "string") {
+    return fail(400, "invalid workflow run idempotencyKey");
+  }
+  if (value.inputDigest !== undefined && typeof value.inputDigest !== "string") {
+    return fail(400, "invalid workflow run inputDigest");
+  }
+  return { ok: true, value: value as unknown as WorkspaceAgentWorkflowRunInput };
+};
+
+const workflowRunRefFromUnknown = (
+  value: unknown,
+): GeneratedResult<WorkspaceAgentWorkflowRunRef> => {
+  if (!isRecord(value)) return fail(400, "invalid inspectWorkflowRun command input");
+  if (typeof value.workflowId !== "string" || typeof value.workflowRunId !== "string") {
+    return fail(400, "invalid workflow run identity");
+  }
+  return {
+    ok: true,
+    value: { workflowId: value.workflowId, workflowRunId: value.workflowRunId },
+  };
+};
+
+const workflowRunsInputFromUnknown = (
+  value: unknown,
+): GeneratedResult<WorkspaceAgentWorkflowRunsInput> => {
+  if (!isRecord(value) || typeof value.workflowId !== "string") {
+    return fail(400, "invalid listWorkflowRuns command input");
+  }
+  return { ok: true, value: { workflowId: value.workflowId } };
+};
+
 const resumeInputRequestFromUnknown = (
   value: unknown,
 ): GeneratedResult<WorkspaceAgentResumeInputRequestCommandInput> => {
@@ -1142,6 +2499,33 @@ export const invokeAgentCommand = command(commandInput, ({ name, input }): Promi
       ? runtime.submitRunInput(submitInput.value.input)
       : rejectFailure(submitInput);
   }
+  if (name === WORKSPACE_AGENT_PRODUCT_COMMAND.SUBMIT_SESSION_TURN) {
+    const sessionInput = sessionTurnInputFromUnknown(input);
+    return sessionInput.ok ? runtime.submitSessionTurn(sessionInput.value) : rejectFailure(sessionInput);
+  }
+  if (name === WORKSPACE_AGENT_PRODUCT_COMMAND.INSPECT_SESSION) {
+    const sessionInput = sessionInspectInputFromUnknown(input);
+    return sessionInput.ok ? runtime.inspectSession(sessionInput.value) : rejectFailure(sessionInput);
+  }
+  if (name === WORKSPACE_AGENT_PRODUCT_COMMAND.LIST_SESSIONS) {
+    return runtime.listSessions();
+  }
+  if (name === WORKSPACE_AGENT_PRODUCT_COMMAND.RUN_WORKFLOW) {
+    const workflowInput = workflowRunInputFromUnknown(input);
+    return workflowInput.ok ? runtime.runWorkflow(workflowInput.value) : rejectFailure(workflowInput);
+  }
+  if (name === WORKSPACE_AGENT_PRODUCT_COMMAND.INSPECT_WORKFLOW_RUN) {
+    const workflowInput = workflowRunRefFromUnknown(input);
+    return workflowInput.ok
+      ? runtime.inspectWorkflowRun(workflowInput.value)
+      : rejectFailure(workflowInput);
+  }
+  if (name === WORKSPACE_AGENT_PRODUCT_COMMAND.LIST_WORKFLOW_RUNS) {
+    const workflowInput = workflowRunsInputFromUnknown(input);
+    return workflowInput.ok
+      ? runtime.listWorkflowRuns(workflowInput.value)
+      : rejectFailure(workflowInput);
+  }
   if (name === WORKSPACE_AGENT_COMMAND.RESUME_INPUT_REQUEST) {
     const resumeInput = resumeInputRequestFromUnknown(input);
     return resumeInput.ok
@@ -1500,10 +2884,29 @@ const renderSvelteKitRemote = (normalized, modules) => normalized.profile === AG
 const renderWorkspaceStaticClient = (normalized, modules) => {
     if (normalized.client.kind === AGENTOS_CONFIG_CLIENT.BROWSER_DIRECT_V1) {
         return `${renderNamedImport(["createWorkspaceAgentClientBridge"], modules.workspaceAgentClient)}
-${renderTypeImport(["CreateWorkspaceAgentClientOptions", "WorkspaceAgentClientBridge"], modules.workspaceAgentClient)}
+${renderTypeImport([
+            "AgentSessionListProjection",
+            "AgentSessionProjection",
+            "WorkflowRunListProjection",
+            "WorkflowRunProjection",
+        ], modules.runtimeRunProjector)}
+${renderTypeImport([
+            "CreateWorkspaceAgentClientOptions",
+            "WorkspaceAgentClientBridge",
+            "WorkspaceAgentProductCommandMap",
+            "WorkspaceAgentProductProjectionTypes",
+        ], modules.workspaceAgentClient)}
+
+export interface GeneratedAgentClientProductProjections extends WorkspaceAgentProductProjectionTypes {
+  readonly session: AgentSessionProjection;
+  readonly sessionList: AgentSessionListProjection;
+  readonly workflowRun: WorkflowRunProjection;
+  readonly workflowRunList: WorkflowRunListProjection;
+}
 
-export type GeneratedAgentClientOptions = CreateWorkspaceAgentClientOptions;
-export type GeneratedAgentClient = WorkspaceAgentClientBridge;
+export type GeneratedAgentClientOptions =
+  CreateWorkspaceAgentClientOptions<WorkspaceAgentProductCommandMap<GeneratedAgentClientProductProjections>>;
+export type GeneratedAgentClient = WorkspaceAgentClientBridge<GeneratedAgentClientProductProjections>;
 
 export const createAgentOSClient = (
   options: GeneratedAgentClientOptions = {},
@@ -1514,17 +2917,33 @@ export const createAgentOSClient = (
 import { invokeAgentCommand, runEventStream } from "./sveltekit.remote";
 ${renderNamedImport(["clientReadable", "selectClientReadable"], modules.clientSvelte)}
 ${renderTypeImport(["AgentClientSnapshot"], modules.clientCore)}
+${renderTypeImport([
+        "AgentSessionListProjection",
+        "AgentSessionProjection",
+        "WorkflowRunListProjection",
+        "WorkflowRunProjection",
+    ], modules.runtimeRunProjector)}
 ${renderTypeImport([
         "CreateWorkspaceAgentClientOptions",
-        "WorkspaceAgentClient",
         "WorkspaceAgentClientBridge",
-        "WorkspaceAgentCommandOutputByName",
+        "WorkspaceAgentProductClient",
+        "WorkspaceAgentProductCommandMap",
+        "WorkspaceAgentProductProjectionTypes",
     ], modules.workspaceAgentClient)}
 ${renderTypeImport(["Readable"], modules.svelteStore)}
 
-export type GeneratedAgentClientOptions = CreateWorkspaceAgentClientOptions;
+export interface GeneratedAgentClientProductProjections extends WorkspaceAgentProductProjectionTypes {
+  readonly session: AgentSessionProjection;
+  readonly sessionList: AgentSessionListProjection;
+  readonly workflowRun: WorkflowRunProjection;
+  readonly workflowRunList: WorkflowRunListProjection;
+}
 
-export interface GeneratedAgentClient extends WorkspaceAgentClientBridge {
+export type GeneratedAgentClientOptions =
+  CreateWorkspaceAgentClientOptions<WorkspaceAgentProductCommandMap<GeneratedAgentClientProductProjections>>;
+
+export interface GeneratedAgentClient
+  extends WorkspaceAgentClientBridge<GeneratedAgentClientProductProjections> {
   readonly snapshot: Readable<AgentClientSnapshot>;
   readonly events: Readable<AgentClientSnapshot["events"]>;
   readonly connection: Readable<AgentClientSnapshot["connection"]>;
@@ -1539,8 +2958,10 @@ const generatedStreamSource: NonNullable<GeneratedAgentClientOptions["streamSour
     }),
 };
 
-const generatedRpcInvoker: WorkspaceAgentClient["invoke"] = (name, input) =>
-  invokeAgentCommand({ name, input }) as Promise<WorkspaceAgentCommandOutputByName[typeof name]>;
+const generatedRpcInvoker = ((name, input) =>
+  invokeAgentCommand({ name, input })) as WorkspaceAgentProductClient<
+  GeneratedAgentClientProductProjections
+>["invoke"];
 
 export const createAgentOSClient = (
   options: GeneratedAgentClientOptions = {},
@@ -1696,12 +3117,6 @@ export const linkWorkspaceStaticTarget = (normalized, options = {}) => {
         };
     }
     const modules = staticTargetModules(packageScope);
-    if (normalized.target.kind !== AGENTOS_CONFIG_TARGET.CLOUDFLARE_DO_V1) {
-        return {
-            ok: false,
-            issues: [{ kind: "unsupported_static_target", target: normalized.target.kind }],
-        };
-    }
     if (normalized.llm.route !== AGENTOS_CONFIG_LLM_ROUTE.OPENAI_CHAT_COMPATIBLE) {
         return {
             ok: false,
@@ -1709,6 +3124,150 @@ export const linkWorkspaceStaticTarget = (normalized, options = {}) => {
         };
     }
     const toolNames = Object.keys(normalized.deployment.manifest.tools ?? {}).sort();
+    const hasChannels = normalized.channels.length > 0;
+    const hasSchedules = normalized.schedules.length > 0;
+    if (normalized.target.kind === AGENTOS_CONFIG_TARGET.NODE_V1) {
+        if (normalized.profile !== AGENTOS_CONFIG_PROFILE.WORKSPACE_V1) {
+            return {
+                ok: false,
+                issues: [{ kind: "unsupported_static_target", target: normalized.target.kind }],
+            };
+        }
+        const authoredManifestToolNames = toolNames.filter((toolName) => normalized.authoredToolNames.includes(toolName));
+        const deploymentJson = {
+            deploymentId: normalized.deployment.deploymentId,
+            backend: normalized.deployment.backend,
+            adapter: normalized.deployment.adapter,
+            codec: normalized.deployment.codec,
+            ...(normalized.deployment.providerStrategy === undefined
+                ? {}
+                : { providerStrategy: normalized.deployment.providerStrategy }),
+            workspace: {
+                binding: normalized.workspace.binding,
+                bindingRef: normalized.workspace.bindingRef,
+                root: normalized.workspace.root,
+                topology: normalized.workspace.topology,
+                providerResourceId: normalized.workspace.providerResourceId,
+            },
+        };
+        const moduleGraph = [
+            { kind: "semantic-json", source: "./manifest.json", imports: ["default as declarations"] },
+            { kind: "semantic-json", source: "./deployment.json", imports: ["default as deployment"] },
+            {
+                kind: "local-runtime",
+                source: modules.localRuntime,
+                imports: ["lowerLocalAgentRuntime"],
+            },
+            {
+                kind: "capability-runtime",
+                source: modules.runtimeCapability,
+                imports: ["runDynamicCapabilityResolvers"],
+            },
+            {
+                kind: "workspace-host",
+                source: modules.workspaceAgentHost,
+                imports: ["WorkspaceAgentCustomCommandInput"],
+            },
+            {
+                kind: "target-runtime",
+                source: modules.runtimeRunProjector,
+                imports: [
+                    "projectAgentSession",
+                    "projectAgentSessions",
+                    "projectRunInspection",
+                    "projectWorkflowRun",
+                    "projectWorkflowRuns",
+                ],
+            },
+            ...generatedToolImports(authoredManifestToolNames),
+            ...generatedDynamicResolverImports(normalized.dynamicResolvers),
+            ...(hasChannels
+                ? [
+                    {
+                        kind: "channel-runtime",
+                        source: modules.runtimeChannel,
+                        imports: ["DefinedChannel"],
+                    },
+                    ...generatedChannelImports(normalized.channels),
+                    {
+                        kind: "channel-registry",
+                        source: "./channels",
+                        imports: ["dispatchGeneratedChannelRequest", "generatedChannels"],
+                    },
+                ]
+                : []),
+            ...(hasSchedules
+                ? [
+                    {
+                        kind: "schedule-runtime",
+                        source: modules.runtimeSchedule,
+                        imports: ["DefinedSchedule"],
+                    },
+                    ...generatedScheduleImports(normalized.schedules),
+                    {
+                        kind: "schedule-registry",
+                        source: "./schedules",
+                        imports: [
+                            "dispatchGeneratedSchedule",
+                            "dispatchGeneratedScheduleDelivery",
+                            "generatedScheduleDefinitions",
+                            "generatedSchedules",
+                        ],
+                    },
+                ]
+                : []),
+        ];
+        return {
+            ok: true,
+            value: {
+                files: [
+                    generatedPath(".agentos/generated/manifest.json", stableJson(normalized.deployment.manifest)),
+                    generatedPath(".agentos/generated/deployment.json", stableJson(deploymentJson)),
+                    generatedPath(".agentos/generated/provenance.json", stableJson(normalized.provenance)),
+                    generatedPath(".agentos/generated/fingerprints.json", stableJson({
+                        deployment: digestText(stableJson(deploymentJson)),
+                        manifest: digestText(stableJson(normalized.deployment.manifest)),
+                        targetModuleGraph: digestText(stableJson(moduleGraph)),
+                    })),
+                    ...(hasChannels
+                        ? [
+                            generatedPath(".agentos/generated/channels.ts", renderChannelRegistry(normalized.channels, modules)),
+                        ]
+                        : []),
+                    ...(hasSchedules
+                        ? [
+                            generatedPath(".agentos/generated/schedules.ts", renderScheduleRegistry(normalized.schedules, modules)),
+                        ]
+                        : []),
+                    generatedPath(".agentos/generated/local.ts", renderLocalAgentApp(normalized, toolNames, modules)),
+                ],
+                moduleGraph,
+                canonicalDeployment: {
+                    profile: normalized.profile,
+                    target: normalized.target.kind,
+                    llmRoute: normalized.llm.route,
+                    client: normalized.client.kind,
+                    workspaceTopology: normalized.workspace.topology,
+                    toolNames,
+                },
+                mount: {
+                    driver: {
+                        kind: "local-node",
+                        target: AGENTOS_CONFIG_TARGET.NODE_V1,
+                    },
+                    projectionSinks: [
+                        "agent.info",
+                        "workspace.state",
+                        "workspace.files",
+                        "runtime.events",
+                        "runtime.input_requests",
+                    ],
+                    providerResourceId: normalized.workspace.providerResourceId,
+                },
+            },
+        };
+    }
+    const target = cloudflareTargetFor(normalized.target);
     const authoredToolNames = new Set(normalized.authoredToolNames);
     const authoredManifestToolNames = toolNames.filter((toolName) => authoredToolNames.has(toolName));
     const deploymentJson = {
@@ -1738,10 +3297,64 @@ export const linkWorkspaceStaticTarget = (normalized, options = {}) => {
         {
             kind: "target-runtime",
             source: modules.cloudflareDoRuntime,
-            imports: normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1
-                ? ["createAgentDurableObject", "installCloudflareWorkspaceOperationProvider"]
-                : ["createAgentDurableObject"],
+            imports: ["createAgentDurableObject"],
         },
+        ...(hasChannels
+            ? [
+                {
+                    kind: "channel-runtime",
+                    source: modules.runtimeChannel,
+                    imports: ["DefinedChannel"],
+                },
+                ...generatedChannelImports(normalized.channels),
+                {
+                    kind: "channel-registry",
+                    source: "./channels",
+                    imports: ["dispatchGeneratedChannelRequest", "generatedChannels"],
+                },
+            ]
+            : []),
+        ...(hasSchedules
+            ? [
+                {
+                    kind: "schedule-runtime",
+                    source: modules.runtimeSchedule,
+                    imports: ["DefinedSchedule"],
+                },
+                ...generatedScheduleImports(normalized.schedules),
+                {
+                    kind: "schedule-registry",
+                    source: "./schedules",
+                    imports: [
+                        "dispatchGeneratedSchedule",
+                        "dispatchGeneratedScheduleDelivery",
+                        "generatedScheduleDefinitions",
+                        "generatedSchedules",
+                    ],
+                },
+            ]
+            : []),
+        ...(normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1
+            ? [
+                {
+                    kind: "capability-runtime",
+                    source: modules.runtimeCapability,
+                    imports: [
+                        "WORKSPACE_OPERATION_HOST_FACT",
+                        "defineHost",
+                        "resolveRuntimeInstallGraph",
+                        "runDynamicCapabilityResolvers",
+                        "workspaceOperations",
+                    ],
+                },
+            ]
+            : [
+                {
+                    kind: "capability-runtime",
+                    source: modules.runtimeCapability,
+                    imports: ["runDynamicCapabilityResolvers"],
+                },
+            ]),
         {
             kind: "provider-runtime",
             source: modules.openAiCompatibleTransport,
@@ -1755,13 +3368,9 @@ export const linkWorkspaceStaticTarget = (normalized, options = {}) => {
                 : ["WORKSPACE_AGENT_COMMAND"],
         },
         ...generatedToolImports(authoredManifestToolNames),
+        ...generatedDynamicResolverImports(normalized.dynamicResolvers),
         ...(normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1
             ? [
-                {
-                    kind: "workspace-binding",
-                    source: modules.workspaceBinding,
-                    imports: ["bindWorkspaceToolsForRuntime"],
-                },
                 {
                     kind: "execution-domain-runtime",
                     source: modules.workspaceEnvCloudflare,
@@ -1788,8 +3397,8 @@ export const linkWorkspaceStaticTarget = (normalized, options = {}) => {
             kind: "target-worker",
             source: "./worker",
             imports: normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1
-                ? [normalized.target.durableObject.className, "Sandbox"]
-                : [normalized.target.durableObject.className],
+                ? [target.durableObject.className, "Sandbox"]
+                : [target.durableObject.className],
         },
         {
             kind: "target-config",
@@ -1810,6 +3419,16 @@ export const linkWorkspaceStaticTarget = (normalized, options = {}) => {
                     manifest: digestText(stableJson(normalized.deployment.manifest)),
                     targetModuleGraph: digestText(stableJson(moduleGraph)),
                 })),
+                ...(hasChannels
+                    ? [
+                        generatedPath(".agentos/generated/channels.ts", renderChannelRegistry(normalized.channels, modules)),
+                    ]
+                    : []),
+                ...(hasSchedules
+                    ? [
+                        generatedPath(".agentos/generated/schedules.ts", renderScheduleRegistry(normalized.schedules, modules)),
+                    ]
+                    : []),
                 generatedPath(".agentos/generated/target.ts", renderStaticTarget(normalized, toolNames, modules)),
                 generatedPath(".agentos/generated/cloudflare-scope.ts", renderCloudflareScopeHelper(normalized, modules)),
                 generatedPath(".agentos/generated/worker.ts", renderCloudflareWorkerEntry(normalized, modules)),
@@ -1836,8 +3455,8 @@ export const linkWorkspaceStaticTarget = (normalized, options = {}) => {
             mount: {
                 driver: {
                     kind: "cloudflare-do",
-                    className: normalized.target.durableObject.className,
-                    binding: normalized.target.durableObject.binding,
+                    className: target.durableObject.className,
+                    binding: target.durableObject.binding,
                 },
                 projectionSinks: normalized.profile === AGENTOS_CONFIG_PROFILE.WORKSPACE_V1
                     ? [